perm filename DPYSER[KA,SYS] blob sn#472060 filedate 1976-08-04 generic text, type C, neo UTF8
COMMENT ⊗   VALID 00127 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00012 00002	SUBTTL III DISPLAY PACKAGE - D. POOLE - NOV 1968
C00014 00003	 BYTE POINTERS INTO BITS THAT SAY SIZE SET BY USER OR UUO
C00016 00004	DWPINI DWPERR DPYATL
C00019 00005	DPYMAKE DPYM1 DPYM3
C00026 00006	DPYXIT DPYXTL DPYM5 DPYM6 DPYM7 DPYM8 PPSET DPYM9
C00030 00007	DPYM2 DDWIPE DDMAP DDMAP1 DPYM4
C00034 00008	DPYKIL DPYKI8 DPYKL1 DPYKML DPYKX0 DPYKX7 DPYKX8 DPYKX9 DPYKL0 DPNONO DPNOTT DPYKI3 HDRCHK
C00043 00009	DPYK10 DPYK11 DPYKFS DPYKF1 DPYKF2
C00046 00010	DPYKI9 DPYKI7 DPYKER DPYK9
C00048 00011	DPYINT NOSTOP L6 L5 L3 DPYXIT
C00051 00012	DPERR ADDRCK NOADDR NODPLK L8 L9
C00054 00013	L2 L1 L1A L4 L7
C00056 00014	PPINIT		PAGE PRINTER STUFF
C00060 00015	PPXFT PPI3 PPI1
C00064 00016	PPFSGE CGETFS UGFS2 UGETFS CGIVFS UGIVFS GETQ UGETF2 UGETF1
C00066 00017	BELOW IS THE PROTOTYPICAL P. OF P. CONTROL BLOCK.
C00071 00018	DTYO DPYTYO TYO0 TYO5 TYO1 TYO2 TYO7 TYO4 DELNOW
C00077 00019	PUTCH1 PUT2CH PUT2C2 PUT2C3 PR1TAB PR1TB1 PRCR PRCR2 PRCR3
C00081 00020	PR1ECR PR1EC1 PR1EC3 PR1EC2 PR1EOL PREOGL SETLL
C00085 00021	EXTBUF L2 L1 GBLK
C00089 00022	GLITCH GLTCH3 PR1EL4 ADJSIZ CNTWRP GLTCH4 GLTCH0
C00093 00023	EOLSET EOLSE2 EOLSE3
C00096 00024	GLNADR GLNAD1 GLNAD2 GLNAD3 GLNAD4 GLNAD6
C00097 00025	GLNAD5 GLNAD7 HELPX
C00099 00026	POSLIN POSLDM POSLDD POSLII NODMDP
C00101 00027	FBLK FB1 PR1FRE PR1ER2 PR1ER3 PR1ERR PR1ER1
C00104 00028	PPOUT SETRST PPRST
C00106 00029	ERRP2 ERRP3
C00108 00030	PPFND1 PFL2 PPFND PPFER
C00111 00031	PPSEL1 PPREL PPREL2 PPREL3 PPREL4 PPSEL0 CLKREL
C00115 00032	PPSEL PPSELN PPACT0 PPACT PACTL1 PACTL2 PACTL3 PACTL4
C00119 00033	PPWAIT PPWAT2 PPWAT3 PPWAT4
C00121 00034	PPYPOS PPYPO1 PPYPO3 PPYPO4 REFPAG
C00124 00035	PPYPO2 PPYPO5 PPYPDN PPYPDM
C00127 00036	PPERS DMERS
C00131 00037	PTMOVE PTMOV1 PTMOV2 PTMOV3 PTMOV4
C00133 00038	PPXSIZ PPX1 PPX2 PPXERR
C00136 00039	DPYCLK CLKL1 CLKRTN
C00140 00040	WHOQUE WHOQ1 WHOQ2 WHOQDM
C00145 00041	FREE GETFS POPAJ CLKWAT ARRRGH
C00147 00042	PRGFND PRGF1 PRGF2 PRGF3 PRGFER PRGFE1 DDFND
C00150 00043	PPIOT
C00151 00044	DPYCLR DPYRST PPCLR PPC1 PPC2 PPC3
C00155 00045	PPNSET PPNST1 PPNST2 SETPHD PPGSET PPGST1
C00157 00046	PPLSET PPYSET PPYS2 PPYDD PPYDM PPYS3 PPYIII
C00159 00047	PPHLD PPHLD1 PPHLD2 AC1CLK
C00161 00048	PPSPY, PPINFO    PPSPY2 PPINF1 PPINF1 PPSPY1
C00167 00049	LEYPOS
C00169 00050	FOOFRL FREEL
C00170 00051	DMUPG CHASEM CHASE3
C00175 00052	DMUDUN DMUCLK QDM QDMPP QDMGLC
C00179 00053	UPGIOT IS THE DEMOCRATIC UUO WHICH ALLOWS ALL MEN,
C00182 00054	LOOP UPGTB SPECOP DONE UPREL1
C00185 00055	SPCTBL SELCHK LOOPS DCHNOK
C00187 00056	ADRRST ADROP ILLAD ILL1 ILLJMS HLTOP UPGER1
C00190 00057	DDUPG DDCWL DDCINC DDWAIT APRONJ
C00194 00058	DDSCHN UPGQ0
C00198 00059	CHKAD CHKAC1 CHKAC2 CHKAC3 CHKAC4 CHKADR CHKADU
C00200 00060	CHAD MYCHN ILLCHN
C00202 00061	PGSET PGSETA PGSET1 PGSET2 PGSL1
C00204 00062	DPYERR DPYER1
C00206 00063	UPGMVM UPGMOV UPGMV
C00209 00064	PGIOT PGSEL VPGACT PGACT PGACL PGAC1 PGCLR PGCLR1
C00212 00065	PGINFO PGCLP PGSZ PGCNT PGXLP
C00215 00066	DPYTY1 DPYERT DPYTYP DPYTY4 DPYTY5 DPYTY2 DPYTY6 DPYTY3
C00219 00067	DPYTL1 DPYTL2 DPTL2A DPTL2B DPYTL3 DPYTL4
C00223 00068	DPYTER STAR IISTAR DMSTAR DMSTA2 STAR0 STAR1
C00227 00069	UNHOLD UNHIII UNHDM
C00231 00070	DPTDD DPTDDK DPYTLN DPYTIM
C00233 00071	QDMR QDMR2 DMNXBK DMNONX DMNON2 DMNON3 DMNON4 DMNON5 DMNOQB DMQGLC DMPPST DMNOHD GLTCHX DMSTHD DMSHFT GLTCHZ CHASPP
C00248 00072	START DAMMIT USUAL QLINE QFIELD QHPOS QLINK QWAKE QCOUNT QTIME QINSTR QLENGTH QFLAGS QTAKR QDMCNT QXY QFREE QPUTR
C00253 00073	QDDR DOXFR
C00257 00074	QDD1 NOPAGE
C00260 00075	DPTDL DPYTLX
C00263 00076	LEERSN RFPCS LEERS LEERS3 LEPGC LEPGC REFLIX REFLINE
C00268 00077	LERFP Q2BLCK LERFP1 GET2Q LERELE PPCLB
C00272 00078	LERDM LERDM2 LEPDM LEPDM2 LEPDM3 DMLED DMLED4 DMLED5 DMLED7 DMLED9 DMEOSL DMEOS2 DMFLUS TBDONE STRTDM DMNDDB
C00284 00079	DPLED DPLEVS DPLEOK
C00289 00080	DPLGC2 DPLGC1 DPTL14 DPLGCP NOLETX
C00292 00081	DPTLE1 DPTL1A DPTL1B DPTL1C DPTL1D
C00295 00082	DPTLE6 DPTLE9 DPTLE7 DPTLE2 DPTLE8 DPTL11 DPTLE3
C00298 00083	DPTLE4 DPTL12 DPTLE5 - EVERYBODY COMES HERE TO EXIT
C00300 00084	DPWT DPWT1 DPWT2
C00303 00085	DPEOSL
C00305 00086	DPEC DPEOPC DPEC1 DPEC2
C00307 00087	DPWPC DPWPC1 DPWPC2 DPWC DPWB
C00309 00088	QBLOCK QBLDBG REQBLK QBLK
C00313 00089	QBLCLK QBLCLC QBLGO
C00316 00090	QBL1 CNXTFR QBL6 QBL7
C00319 00091	QOOB GIVQB QBLERR WAKEQ WAKEQ1
C00321 00092	QBL3 MAKFRM QBL4
C00324 00093	QBL8 QBL5 QBL9 QBLXIT DDQCHK DDQCH1 DDQCH4 DDQCE1,2,3 DDCKR1,2,3 DDCHER DDTSCH DDTSC1,2 DDTSE1,2,3,4
C00330 00094	DDSTRT NEWFRM SCNLOP
C00333 00095	RESCAN DDEXIT
C00335 00096	DDREQ DDREQ1 DDREQ2 DDREQ3
C00336 00097	DEQ DEQWAK DEQ1 DEQ2 GIVQ
C00339 00098	PPXFR
C00343 00099	PPXFR1 PPXFR2 PPXFR3 PPXFR4 ILLPP
C00345 00100	ERASE CWAIT
C00347 00101	CURSOR CDX CURS2 CURS1
C00350 00102	CMAKE CMAKE1 CMAKE2
C00353 00103	LEXFR LEXFR4
C00356 00104	LEXFR1 LEXFR2 LEXFR3
C00358 00105	WSE WHOWRT WHOWR1 WHOWR2 WHOWR3
C00361 00106	POG POG0 POG1 POGCLK PPSTAR POGX1 POGX2  -  USER DATA DISC PROGRAM
C00364 00107	ISYNC DDINT DDINT2
C00366 00108	DDNX DDINT1 DDCMR DDCLK DDIXIT DDIXI1
C00368 00109	DDILL
C00369 00110	DEFINITIONS FOR DATA DISC ALLOCATION
C00371 00111	DDINI DDINI1 DDINI2 DDAVST DDLIST VDSYNC
C00375 00112	DDCHAN DDCDSP DDAREL DDARL1
C00377 00113	DDCREL DDCRL1 DDREL SCNONJ DDREL2
C00379 00114	DDCGET DDAGE1 DDCG1 DDAGE3 DDAGET DDAGE2 DDGET2 DDGET3
C00383 00115	DDFLSH DDFLS0 DDFL01 DDFLS1 DDFLS2 DDFLS3 DDFLS4 DDFLS9 DDFLSX DDCHEK DDCSGT DDSGET DDCFND
C00387 00116	DDCSST DDSSET VDBIT VDSTR1 VDSTRU VDSTR2 VDOUT VDOUT1 VDOUT2 VDOUT3 VDOUTP VDOUP0 VDOUP1 VDOUP2
C00393 00117	VDSMAP VDMAP1 VDMP1A
C00397 00118	VDMAP2 VDMAP3 VDMP30 VDMP31 VDGTIE VDMP32 VDMAP5 VDMAP4 VDDSP VDSTIE
C00400 00119	VDSET VDIOR VDIOR1 VDACM VDRST VDRST1 VDNORM VDRST2 VDNOR2 VDNOR3
C00403 00120	VDWCHK VDWCHL VDWOK VDWLUZ VDCCHK VDCCK0 VDCCK1 VDCCK2 VDCCK3
C00405 00121	BEGIN WHOSER  ↔ SUBTTL WHO LINE GENERATOR 	WHOINI
C00408 00122	WHOSER WHOIII WHODO WHODO9 WHODO4 WHODO3 WHODO2 WHODO1 WHOCLR WHODM WHODO5
C00416 00123	WHOSIX WHOSXX WSDPAD WSDPD3 WSDPD2 WSDPD0 WSDPD1 WPER2D W0PD2 DECPDF WHPRNT
C00419 00124	ALWAYS ALWAY1 ALWAY2 ALWAY3 XTALL NOXTIM DOTIME WHOTIM WMIN
C00424 00125	WHOSET WHOLIN WLRET WLRET1
C00428 00126	WSIZE WALIAS
C00433 00127	WHOSYS NONULL WHOSY1 WRUN1 WRUN2 WHODDC
C00445 ENDMK
C⊗;
SUBTTL III DISPLAY PACKAGE - D. POOLE - NOV 1968
COMMENT ⊗
	THESE ARE THE GLORIOUS, WORLD-SAVING III DISPLAY
ROUTINES.  FOR THEIR FIRST TRICK, THEY WILL IMPERSONATE
W. F. WEIHER, THUS STARTING THE PROGRAM ON A NOTE OF
LIGHT HUMOR.

⊗

BEGIN DPYSER

↓CHR←TEM	;SAME AS CHREC IN SCNSER

;; NOW SOME DISPLAY OPCODES AND MACROS FOR GENERATING DP INSTRS.

DISJMP←←20	;DP JMP INSTR. OPCODE.
DISJMS←←4	; JMS (STORES TWO WORDS)
DISJSR←←24	; STORES ONLY RETURN ADDR.
DISRST←←14	;RESTORE.
DISSEL←←10	;SELECT.
DISNOP←←14	;ACTUALLY RST, BUT A GOOD NOP WITH ALL BITS OFF.

DEFINE LVW(X,Y,TYPE,MODE,BRT,SIZ)	;ASSEMBLES A LONG VECTOR.
  { MVW1 (MODE,TYPE,BRT,SIZ)	;TWIDDLE PARAMS.
	BYTE (11)<X>,<Y>(3)B,S(2)MD,TT(3)3 }	;ASSEMBLE INSTR.
DEFINE MVW1 (M,T,BRT,SIZ)
 {IFIDN {M}{A}{MD←1;}MD←0	;MODE = `A' FOR ABSOLUTE.
  IFIDN {T}{I}{TT←2;}TT←0	;TYPE = `I' FOR INVISIBLE.
  IFIDN {BRT}{}{B←0;}B←BRT	;BRT = 0 IF OMITTED.
  IFIDN {SIZ}{}{S←0;}S←SIZ	;SAME FOR SIZ.
}
DEFINE ERMS (X) {JSA J,ERRP
POINT 7,[ASCIZ ⊗X
⊗]
}
DEFINE CW (C1,B1,C2,B2,C3,B3) {<BYTE (8)<B1>,<B2>,<B3>(3)<C1>,<C2>,<C3>>!4}
GLOBAL DDTAB,JB2SWP	;STUPID FAIL
; BYTE POINTERS INTO BITS THAT SAY SIZE SET BY USER OR UUO

SIZSBU:	POINT 1,GWORD(DDB),0	; IF 1, SAYS LINES/GLITCH OR GLITCHES/PAGE SET BY USER LAST
POSSBU:	POINT 1,GWORD(DDB),1	; SAYS Y-POS. SET BY USER COMMAND (RATHER THAN UUO)
LHCSBU:	POINT 1,GWORD(DDB),2	; SAME FOR LINE HOLD COUNT
GHCSBU:	POINT 1,GWORD(DDB),3	; SAME FOR GLITCH HOLD COUNT
HLINES:	POINT 9,GWORD(DDB),17	; POINTS TO NUMBER OF LINES BEFORE HOLDING
HGLTCH:	POINT 9,GWORD(DDB),26	; POINTS TO NUMBER OF GLITCHES BEFORE HOLDING
;	POINT 9,GWORD(DDB),35	; CHAR WHICH ACTIVATED LINED

; NORMAL VALUES FOR THE PAGE PRINTER

NGSIII←←14		; GLITCHES/PAGE FOR III DISPLAYS
NGSDD←←4		; GLITCHES/PAGE FOR DD DISPLAYS
NGSDM←←=7		; GLITCHES/PAGE FOR DM DISPLAYS
NLSIII←←2		; LINES/GLITCH FOR III
NLSDD←←11		; LINES/GLITCH FOR DD
NLSDM←←3		; LINES/GLITCH FOR DM
YPIII←←600		; Y-POSITION FOR III
YPDD←←660		; Y-POSITION FOR DD (line 4 of 40.)
YPDM←←526		; Y-POSITION FOR DM (line 4 of 24.)
↑NDDSPQ←←60		;# SPARE DD/DM QUEUE BLOCKS (TIRED OF BEING SCREWED -REG)

↑HGTIII←←=42		;Number of lines on screen for III (slightly arbitrary)
HGTDD←←=40		;Number of lines on screen for DD
HGTDM←←=24		;Number of lines on screen for DM
;DWPINI DWPERR DPYATL
COMMENT ⊗  THE FOLLOWING IS SYSTEM START TIME INITIALIZING CODE.
 	MUCH OF IT IS IN TEMPORARY FORM.
⊗

↑DWPINI:  
	SKIPE	IIIOFF		;SUPPRESSING III TODAY?
	TDZA	AC1,AC1		;YES.  FLUSH CONSZ INSTRUCTION
	MOVEI	AC1,400000	;NO. SET CONDITION BIT IN DPYCON
	HRRM	AC1,DPYCON	;...
	MOVEI	AC1,2		;INITIALIZE COMMON DD CURSOR BUFFER
	MOVEM	AC1,DDCURS+2	;BY PROPAGATING A ZERO GRAPHICS WORD DOWN IT
	MOVE	AC1,[XWD DDCURS+2,DDCURS+3]
	BLT	AC1,DDCURS+21	;ALL THE WAY (TOO BAD THAT SOME PEOPLE CAN'T COUNT)
	MOVEI TAC,DPYNUM
	MOVEM TAC,DRUNCT	;INIT. PTR. TO NEXT DPY TO RUN.
	HRLOI TAC,377777
	MOVEM TAC,DDCNT
	SETZM FSWTHD		;CLEAR FS WAIT LIST.
	SETZM FSWT2H		;AND THE WAIT LIST WAIT LIST.
	SETZM DDSTART		; CLEAR ALL THE DATA DISK FLAGS
	SETZM DDRUN
	SETZM STRTBL		; ZERO OUT ALL THE IMPORTANT TABLES
	MOVE TAC,[XWD STRTBL,STRTBL+1]
	BLT TAC,RSTTBL+DPYNUM-1
	MOVE TAC,[POINT 36,CLKQUE-1,35]
	MOVEM TAC,CLKQ		;INIT. CLOCK QUEUE PTR.
	MOVE TAC,[IOWD LCPDL,CLKPD]	;..ALSO CLOCK PDL.
	MOVEM TAC,DPYPDL
	MOVSI TAC,770000	; RESTORE AVAILABLE MESSAGES
	HLLM TAC,DPYAVL+1
	HLLM TAC,WHOSEL		; SYSTEM WHO LINE FOR ALL AVAILABLE IIIS
	MOVSI TAC,77		; DESELECT EVERYONE
	HLLM TAC,DPYHLD		; HOLDING MESSAGE TOO
IFN FTOIKB, < CONO KBD,SCNCHN >		;GIVE INTERRUPT CHANNEL TO KEYBOARD SCANNER.
	CONO DDD,10
	PUSHJ P,DDINI
	JRST WHOINI

DWPERR:	PUSHJ P,DISMES
	ASCIZ /CATASTROPHIC ERROR FROM DPYSER
/
DPYATL:	PUSHJ	P,DISFLUSH
	PUSHJ	P,WDDTCA
	HALT	AUTOLOAD
;DPYMAKE DPYM1 DPYM3
; THIS ROUTINE MAKES UP A PROGRAM HEADER AND LINE EDITOR BUFFER.
; IT EXPECTS THE LINE NUMBER IN TAC1. PRESERVES ALL OTHER ACCUMULATORS.
; SKIPS UPON SUCCESS. IF FAILURE, WILL PLANT A CLOCK REQUEST AND
; TRY TO GET ONE LATER.

↑DPYMAKE:
	SKIPE LETAB(TAC1)	; DO WE ALREADY HAVE A PROGRAM HEADER?
	JRST CPOPJ1		; YES, GIVE SUCCESS RETURN
	PUSH P,TAC
	PUSH P,DAT
	PUSH P,DDB
	PUSH P,AC1
	PUSH P,AC2
	PUSH P,AC3
	HLRO TAC,LINTAB(TAC1)	;-1 IN LH MEANS NOT DD, RH HAS LINE BITS
	HLL TAC1,LINTAB(TAC1)
	TLNN TAC1,DDDLIN
	JRST DPYM1
	MOVSI TAC,100-DDL0(TAC1);BH 12/4/74 WAS 400100, UNHIDE NOW DEFAULT
	PUSHJ P,DDAGET		;FIRST MAKE SURE WE HAVE A CHANNEL FOR DD
	JRST DPYXTL		;GO DIRECTLY TO JAIL
	ANDI TAC,-1		;LEAVE ONLY DD CHANNEL NUMBER (RH)
DPYM1:	MOVEI AC3,DHFS
	PUSHJ P,SFSGET
	JRST DPYM8
	HRRZ DDB,AC1
	SETZM (AC1)		; FIRST, ZERO THE THING OUT
	HRLZ AC2,AC1
	HRRI AC2,1(AC1)
	MOVE AC3,AC1
	BLT AC2,DPYLEN-1(AC3)
	MOVEI AC2,DISRST!60	; NOW SET UP THE STARTUP WORD TO RESTORE THE POSITION VECTOR
	HRLI AC2,PRGSAV(AC1)	; THAT WAS STORED LAST TIME THE DPY WAS STOPPED
	MOVEM AC2,(AC1)
	HRLI AC2,LEB+1(AC1)	; THE LINE EDITOR DOES THIS TOO
	MOVEM AC2,LEPPV+4(AC1)
	SETZM LEB(AC1)
	HRLI AC2,LEB(AC1)	; SET UP THE LINE EDITOR CALL
	HRRI AC2,DISJMS
	MOVEM AC2,LEJMS(AC1)
	HRRI AC2,DISJMP		; FILL UP THE LINE EDITOR BUFFER WITH RETURN JUMPS
	MOVEM AC2,LEBUF(AC1)
	HRLI AC2,WHOCALL(AC1)	; MAKE RESTART POINT JUMP BACK TO WHO LINE CALL
	MOVEM AC2,RTJMP(AC1)
	HRLI AC2,LEBUF(AC1)	; NOW BLT THE RETURN JUMP ALL OVER THE
	HRRI AC2,LEBUF+1(AC1)	; LINE EDITOR BUFFER.
	BLT AC2,LEHPOS-1(AC1)
	MOVSI AC3,(TAC)		; DD CHANNEL OR, IF NOT DD, BITS INDICATING DPY TYPE
	HRRI AC3,(TAC1)		; TTY LINE NUMBER
	MOVEM AC3,PRGNUM(DDB)
	PUSHJ P,PPINIT		;GET PAGE PRINTER SET UP FOR EACH DPY.
	JRST DPYM7
	PUSHJ P,PPSET
	TLNE TAC1,DDDLIN
	JRST DPYM2		; DO SPECIAL DD STUFF (GET CHANNEL & ERASE IT)
	TLNE TAC1,DMLIN
	JRST DPYM4		; Now go initialize DM output queues
	MOVNI AC3,-DPYL0(TAC1)	; MUST BE A III
	MOVE AC2,[BYTE (12)0,7777,DISSEL]
	MOVEM AC2,PSELC(DDB)
	MOVSI AC2,400040	; NOW MAKE UP SELECT WORD
	LSH AC2,(AC3)		; PUT A BIT IN THE FIRST TWO 12-BIT FIELDS
	XOR AC2,[77770000]	; COMPLEMENT THE SECOND FIELD
	ORI AC2,DISSEL
	MOVEM AC2,PSELA(DDB)	; AND THIS IS OUR SELECT WORD
	MOVEM AC2,PSELB(DDB)	; AND OUR SPARE SELECT WORD
	AND AC2,[77B5]		; MASK OUT ALL BUT SELECT BIT
	ANDCAM AC2,DPYAVL+1	; DESELECT THIS CONSOLE FROM AVAILABLE MESSAGE
	ANDCAM AC2,WHOSEL	; DESELECT THIS CONSOLE FROM SYSTEM WHOLINE
	LSH AC2,-=12		; PUT BIT IN 'RESET' FIELD
	ORM AC2,DPYAVL+1	; BE SURE TO RESET THIS CONSOLE TOO
	ORM AC2,WHOSEL		; BE SURE TO RESET THIS CONSOLE TOO
	MOVE AC2,[LVW (-5,-14)]	; MAKE A CURSOR FOR THE LINE EDITOR
	MOVEM AC2,LEPPV+1(DDB)
	MOVE AC2,[LVW (12,0)]
	MOVEM AC2,LEPPV+2(DDB)
	MOVE AC2,[LVW (-5,14)]
	MOVEM AC2,LEPPV+3(DDB)
	MOVE AC2,[LVW (0,0,I)]	; NOW A NULL VECTOR FOR THE LEFT MARGIN
	MOVEM AC2,LELMARG(DDB)

; MORE INITIALIZE CODE FOR A NEW PROGRAM-LINED-BUFFER THING
DPYM3:	MOVEI AC2,LEBUF+BUFL-4(DDB)
	MOVEM AC2,MAXPT(DDB)	; MAKE UP POINTER TO END OF LINE EDITOR BUFFER
	MOVNI AC1,24000/BLKSIZ	; 24000 WORDS MAXIMUM TOTAL PROGRAMS
	MOVEM AC1,BLKTOT(DDB)	;HOW MANY MORE BLOCKS EACH USER GETS.
	MOVEI AC1,DISNOP
	MOVEM AC1,WHOCALL(DDB)	;NO WHO LINE YET.
	MOVEM AC1,LEPOS(DDB)	; NORMAL VERTICAL POSITION
	MOVEM AC1,PGCALL(DDB)	;NO PG'S.
	MOVEM AC1,LEPPV(DDB)
	MOVEI AC1,400000
	MOVEM AC1,PRGACT(DDB)	;P OF P 0 ACTIVE.
	MOVEM AC1,USRACT(DDB)
	MOVEI AC1,3		; BUMP NUMBER OF SPARE FREE BLOCKS
	ADDM AC1,DPYFS+SPFSN
	ADDM AC1,SPFSNT
;DPYXIT DPYXTL DPYM5 DPYM6 DPYM7 DPYM8 PPSET DPYM9

; NOW SET UP THE POINTERS IN THE TABLES TO GET THE DP STARTED
; AND STOPPED ON THIS PROGRAM

	HRL AC2,DDB		; NOW INITIALIZE ALL THE APPROPRIATE TABLES
	HRRI AC2,DISJMP		; THIS LITTLE JUMP GOES TO DPYTAB
	HRLI AC3,PRGSTP(DDB)
	HRRI AC3,DISJMS		; THIS LITTLE JUMP GOES TO STPTBL
	HRLI AC1,PSELB(DDB)
	HRRI AC1,DISJMP		; AND THIS LITTLE JUMP WENT WEE WEE WEE
	MOVEI DAT,LETAB(TAC1)	;Give the header a pointer to
	MOVEM DAT,LETBPT(DDB)	; its LETAB entry.
	MOVEI DAT,PSELA(DDB)
	CONO PI,PIOFF		; ALL THE WAY INTO RSTTBL
	SKIPE LETAB(TAC1)	; DID SOMEONE SNEAK IN UNDER US?
	JRST DPYM5
	HRRZM DDB,LETAB(TAC1)	; INITIALIZE LINE EDITOR TABLE TOO
	CONO PI,PION
	TLNE TAC1,DMLIN
	JRST DPYM9		;Erase DM screen and start tty
	TLNN TAC1,DISLIN
	JRST DPYXIT		;THAT'S ALL FOR DD
	MOVEM DAT,SELTBL-DPYL0(TAC1)
	MOVEM AC3,STPTBL-DPYL0(TAC1)	;IN THIS ORDER
	MOVEM AC1,RSTTBL-DPYL0(TAC1)	;WE SHOULDN'T NEED
	MOVEM AC2,STRTBL-DPYL0(TAC1)	;TO KEEP PI'S OFF
DPYXIT:	AOS -6(P)		;WE HAVE WON
DPYXTL:	POP P,AC3
	POP P,AC2
	POP P,AC1
	POP P,DDB
	POP P,DAT
	POP P,TAC
	POPJ P,

DPYM9:
IFN FTDM,<
	MOVEI J,(DDB)		;Dpy header address into J for LEPDM2
	PUSH P,CHR
	OFFSCN			;LEPDM2 expects scanner off and turns it on
	PUSHJ P,LEPDM2		;Erase DM screen (calls STRTDM)
	POP P,CHR
>;FTDM
	JRST DPYXIT

DPYM5:	CONO PI,PION
	TLNE TAC1,DDDLIN
	JRST DPYM6
	PUSHJ P,DPYKFS		;III OR DM -- JUST RET FS
	JRST DPYXIT

DPYM6:	HRRZM DDB,DPRLSF(DDB)	;DD - DEFER FS RET FOR DDWIPE
	MOVSI TAC,100-DDL0(TAC1)
	HLR TAC,PRGNUM(DDB)
	PUSHJ P,DDREL		;BUT GIVE BACK CHNL NOW
	JRST DPYXIT

DPYM7:	PUSHJ P,DPYKF2		;RET HDR
DPYM8:	JUMPL TAC,DPYXTL
	HRLI TAC,100-DDL0(TAC1)
	PUSHJ P,DDREL		;RELEASE DD CHNL
	JRST DPYXTL

↑PPSET:	HRRZM DDB,HEDPTR(AC1)	;MAKE PP0 CONT. BLK. POINT AT HEADER.
	HRLI AC1,DISJMP		;ASSEMBLE JMP TO PP 0.
	MOVSM AC1,PPCALL(DDB)	;HAVE HEADER CALL THE PP.
	HRRZM AC1,CURPP(DDB)	;MAKE P OF P 0 THE CURRENT ONE.
	MOVEI AC3,PPCALL+1(DDB)	;RETURN ADDR. TO HEADER FROM PP.
	HRLM AC3,PPRJMP(AC1)	;PUT IN PP RETURN JMP.
	POPJ P,
;DPYM2 DDWIPE DDMAP DDMAP1 DPYM4

DPYM4:
IFN FTDM,<
;Make each DM output queue header point to itself
	MOVEI AC3,HGTDM
	MOVEM AC3,DPYHGT(DDB)	;Set up size of display's screen
	MOVEI AC1,DMLEPT-QLINK(DDB)
	HRL AC1,AC1
	MOVEM AC1,DMLEPT(DDB)
	MOVEI AC1,DMSPPT-QLINK(DDB)
	HRL AC1,AC1
	MOVEM AC1,DMSPPT(DDB)
	MOVEI AC1,DMPPPT-QLINK(DDB)
	HRL AC1,AC1
	MOVEM AC1,DMPPPT(DDB)
	MOVEI AC1,DMUSER-QLINK(DDB)
	HRL AC1,AC1
	MOVEM AC1,DMUSER(DDB)
	MOVEI AC1,DMWHO-QLINK(DDB)
	HRL AC1,AC1
	MOVEM AC1,DMWHO(DDB)
>;FTDM
	JRST DPYM3

;GETTING NEW DATA DISC CHANNEL. FIRST DESELECT AVAILABLE MSG,
;THEN ERASE CHANNEL, THEN SELECT CONSOLE TO CHANNEL.

DPYM2:	MOVEI AC3,HGTDD
	MOVEM AC3,DPYHGT(DDB)	;Set up size of display's screen
	MOVE AC2,AVLBIT
	OFFSCN			;TURN OFF SCANNER CHANNEL
	ANDCAB AC2,VDPRM-DDL0(TAC1)
	MOVEM AC2,VDTMP(DDB)
	ONSCN			;TURN ON SCANNER CHANNEL
	HRLI DDB,DDWIPE
	CONO PI,PIOFF
	IDPB DDB,CLKQ
	CONO PI,PION
	JRST DPYM3

;HERE AT CLOCK LEVEL (CAN'T CALL QBLOCK FROM CH5) FOR DD TO ERASE NEW CHANNEL
DDWIPE:	SKIPE DDB,DPRLSF(DAT)
	JRST DPYKFS		;DPYMAKE WAS ABORTED - RET FS NOW
	PUSHJ P,GETQ
	HRRZ AC2,CURPP(DAT)
	ADDI AC2,PPENQ
	MOVEM AC2,QCOUNT(AC1)
	AOS (AC2)		;WILL HOLD UP BOTH DPLED & DPYTYP
	HRLI DAT,DDMAP
	MOVEM DAT,QWAKE(AC1)
	JRST LEERS3

;HERE AFTER ERASE IS FINISHED. NOW THAT CHANNEL IS CLEAN, WE LET HIM SEE IT.
DDMAP:	HLRZ AC1,PRGNUM(DAT)
	HRRZ TAC,PRGNUM(DAT)
	SUBI TAC,DDL0
	PUSHJ P,VDBIT
	OFFSCN			;TURN OFF SCANNER CHANNEL
	IORM AC3,VDTMP(DAT)
	IORM AC3,VDPRM(TAC)
	ONSCN			;TURN ON SCANNER CHANNEL
	MOVSI AC3,-DDNUM	;PULL BACK KBD-MAPPERS FROM SYSDWN
DDMAP1:	LDB AC2,[POINT PUNITS,LINTAB+DDL0(AC3),35]
	CAIN AC2,DDL0(TAC)
	MOVEM AC2,VDTIE(AC3)
	AOBJN AC3,DDMAP1
	PUSHJ P,VDOUTP		;PROPAGATE VDOUT TO ALL MAPPERS
	MOVEI DAT,DDL0(TAC)
	JRST DPYTYP		;IN CASE PP XFER WAS FLUSHED
;DPYKIL DPYKI8 DPYKL1 DPYKML DPYKX0 DPYKX7 DPYKX8 DPYKX9 DPYKL0 DPNONO DPNOTT DPYKI3 HDRCHK
; ENTER HERE AT CLOCK LEVEL WITH LINE NUMBER IN TAC TO
; FLUSH A DPY BUFFER, IF THAT IS WHAT IS CALLED FOR.

DPYKL0:	TRO TAC,100		; HERE FROM CLOCK QUEUE WITHOUT HIGH-ORDER LINE BIT
↑DPYKIL:
	MOVE AC1,LINTAB(TAC)
	TLNN AC1,DISLIN!DDDLIN!DMLIN
	JRST DPYKER
	SKIPE AC1,LETAB(TAC)
	SETZM LECLIN(AC1)	; CLEAR FLAG THAT SAYS CLOCK REQUEST IS IN
IFN FTDM,<
	MOVSI AC1,KILTTY
	TDNN AC1,TTYTAB(TAC)	; Is TTY DDB marked for extinction by TTYKIL?
>;FTDM
	SKIPN TTYTAB(TAC)	; FIRST, IS TTYSER THROUGH WITH IT?
	SKIPN AC1,LETAB(TAC)	; Used to be SKIPG to not kill if line text present
	POPJ P,			; NO, LEAVE IT AROUND
	SKIPE LEACT(AC1)	; HAS THE LINE EDITOR BEEN ACTIVE IN THE LAST MINUTE?
	JRST DPYKI9		; YES, WAIT ANOTHER MINUTE
	SKIPN LEENQ2(AC1)	; IF HE'S REFRESHING OR HELPING,
	SKIPE LEENQ(AC1)	; OR IF HIS LINE EDITOR IS IN THE QUEUE
	JRST DPYKI7		; PLANT ANOTHER CLOCK REQUEST TO KEEP US AROUND
	HLRZ AC2,PPCALL(AC1)	; OR IF HE HAS ANY PIECE OF PAPER QUEUED
DPYKI8:	SKIPE PPENQ(AC2)	; ANYTHING IN QUEUE?
	JRST DPYKI7
	HRRZ AC2,LINK(AC2)	; PICK UP POINTER TO NEXT PIECE OF PAPER CONTROL BLOCK
	JUMPN AC2,DPYKI8	; LOOP BACK IF ANY
	HRRZ DDB,AC1		; DPY HEADER ADDRESS
	HLL DDB,LINTAB(TAC)	; GET BITS INDICATING TYPE OF DISPLAY
	PUSHJ P,PGCLR		; CLEAR ANY AND ALL PIECES OF GLASS
	OFFSCN			;Keep scanner off until we have cleared LETAB now
IFN FTHDRCHK,< PUSHJ P,HDRCHK > ;See if FS word at end of dpy hdr is ok
	TLNN DDB,DMLIN
	JRST DPYKI3
	HRRZ AC1,DMLEPT(DDB)	;Make sure all DM queues are empty
	HRRZ AC2,DMSPPT(DDB)
	CAIN AC1,DMLEPT-QLINK(DDB)
	CAIE AC2,DMSPPT-QLINK(DDB)
	JRST DPYKI4		;Not empty, wait a tick and check again
	HRRZ AC1,DMPPPT(DDB)
	HRRZ AC2,DMUSER(DDB)
	CAIN AC1,DMPPPT-QLINK(DDB)
	CAIE AC2,DMUSER-QLINK(DDB)
	JRST DPYKI4		;Not empty, wait a tick and check again
	HRRZ AC1,DMWHO(DDB)
	CAIN AC1,DMWHO-QLINK(DDB)
	JRST DPYKI3		;All empty, now flush dpy header
DPYKI4:	ONSCN			;Not empty, wait a tick and check again
	JRST DPYKI7

IFN FTHDRCHK,<
;Bug trap to see if last word in dpy header's FS block has been clobbered
;Call with ptr to dpy hdr in DDB
HDRCHK:	PUSH P,TAC
	MOVE TAC,RDPYLN-2(DDB)	;Get FS word following dpy hdr
	CAMN TAC,[400000+RDPYLN,,0]
	JRST TPOPJ		;OK
	POP P,TAC
	PUSHACS
	PUSHJ P,DISMES
	ASCIZ/
FS WORD AT END OF DPY HEADER CLOBBERED.  WILL FIX.
/
	PUSHJ P,DISFLU
	POPACS
	PUSHJ P,WDDTCA
	PUSH P,TAC
	MOVE TAC,[400000+RDPYLN,,0]
	MOVEM TAC,RDPYLN-2(DDB)
	POP P,TAC
	POPJ P,
>;FTHDRCHK

SPIONJ:	CONO PI,PION
	JRST SCNONJ		;Now turn on scanner channel and return

DPYKI3:
IFN FTHDRCHK,< PUSHJ P,HDRCHK > ;See if FS word at end of dpy hdr is ok
	CONO PI,PIOFF
IFN FTDM,<
	MOVSI AC1,KILTTY
	TDNN AC1,TTYTAB(TAC)	; Is TTY DDB marked for extinction by TTYKIL?
>;FTDM
	SKIPN TTYTAB(TAC)	; ONE LAST CHECK!
	SKIPN LETAB(TAC)	; Used to be SKIPG to not kill if line text present
	JRST SPIONJ		; NOTHING TO DO but turn on scanner and PI
	SETZM LETAB(TAC)
	JUMPGE DDB,DPYKL1	; JUMP UNLESS III
	SETZM RSTTBL-DPYL0(TAC)
	SETZM STPTBL-DPYL0(TAC)
	SETZM STRTBL-DPYL0(TAC)
DPYKL1:	CONO PI,PION
	PUSH P,DDB
	SKIPN DDB,TTYTAB(TAC)
	JRST DPNOTT
	TRNN DDB,-1
	JRST DPNONO		;This ain't supposed to happen
	PUSH P,IOS
	PUSH P,TAC
	MOVE IOS,DEVIOS(DDB)
	MOVE TAC1,TAC		;Line number
	HLL TAC1,LINTAB(TAC1)
	PUSHJ P,TTYKL5		;Flush TTY DDB now and TURN ON SCANNER
	POP P,TAC
	POP P,IOS
	JRST DPNOT2

DPNONO:	PUSHACS
	HRRZ TAC,TAC
	PUSH P,TAC
	PUSHJ P,DISERR
	[ASCIZ/NO TTY DDB AT DPYKIL BUT TTYTAB NON-ZERO FOR TTY/]
	DISARG OCT,<-1(P)>
	[ASCIZ/
/]
	-1
	SUB P,[1,,1]
	PUSHJ P,DISFLU
	POPACS
	PUSHJ P,WDDTCA
	SETZM TTYTAB(TAC)
	JRST DPNOTT

DPNOTT:	ONSCN
DPNOT2:	POP P,DDB
IFN FTHDRCHK,< PUSHJ P,HDRCHK > ;See if FS word at end of dpy hdr is ok
	TLNN DDB,DMLIN
	JRST DPNODM		;Not DM
	PUSH P,TAC
	PUSH P,DDB
	HRRZ TAC1,TAC		;Line number, no bits
	PUSHJ P,DMBONG		;Clear ESC and META flag bits and send the DM a beep
	POP P,DDB
	POP P,TAC
DPNODM:	HRRZ AC2,DDB		;DPY HEADER ADDRESS
IFN FTHDRCHK,< PUSHJ P,HDRCHK > ;See if FS word at end of dpy hdr is ok
	MOVE J,JOBNM1
DPYKML:	CAIN AC2,@DPYMAP(J)
	SETZM DPYMAP(J)		;CLEAR GUY MAPPED TO US
	SOJG J,DPYKML
	PUSH P,DDB		;BH 12/3/74 FLUSH ANYBODY KBD-MAPPED TO US
	MOVE DDB,[-DDNUM,,DDL0]	;BH (12/8/74 JUST DD LINES, NOT III)
	MOVEI AC3,(TAC)
DPYKX0:	CAIN AC3,(DDB)		;BH OK IF THIS IS THE SAME TTY
	JRST DPYKX9
	LDB AC1,[POINT PUNITS,LINTAB(DDB),35]
	CAIE AC1,(AC3)		;BH OR IF NOT MAPPED TO US
	JRST DPYKX7
	HRRM DDB,LINTAB(DDB)	;BH 12/30/74 FLUSH KBD MAP AND DANGLING ESC
	MOVEI AC1,(DDB)		;AT DPYKX8 AC1 MUST HAVE WHO KBD-MAPPED TO
	JRST DPYKX8		;IF WE CHANGE KBD MAP WE BETTER MAKE HIM LOOK

DPYKX7:	CAME AC3,VDTIE-DDL0(DDB);MIGHT BE TIED HERE EVEN IF NOT KBD-MAPPED
	JRST DPYKX9
DPYKX8:	HRRZM AC1,VDTIE-DDL0(DDB)
	PUSH P,TAC
	MOVEI TAC,-DDL0(DDB)
	PUSHJ P,VDOUT		;MAKE HIM SEE HIMSELF
	POP P,TAC
DPYKX9:	AOBJN DDB,DPYKX0	;BH LOOP THRU ALL DPYS
	POP P,DDB		;BH
;DPYK10 DPYK11 DPYKFS DPYKF1 DPYKF2

	PUSHJ P,DPYKFS		;GIVE ALL THE CORE BACK
	JUMPL DDB,DPYK11	;JUST DIDDLE SELECT FOR III
	TLNN DDB,DDDLIN
	POPJ P,			;AGAIN DM'S SEEM TOO EASY
DPYK10:	MOVSI TAC,100-DDL0(TAC)
	HLR TAC,PRGNUM(DDB)	;DD CHANNEL NUMBER
	PUSHJ P,DDREL
	MOVEI AC1,(TAC)		;DD CHANNEL NUMBER, USED BY VDBIT
	LDB TAC,[220600,,TAC]	;LINE NUMBER RELATIVE TO DDL0, USED BY VDOUTP
	PUSHJ P,VDBIT
	ANDCAM AC3,VDPRM(TAC)
	MOVE AC3,AVLBIT
	IORM AC3,VDPRM(TAC)
	JRST VDOUTP

DPYK11:	MOVNI TAC,-DPYL0(TAC)	; NEGATIVE OF III NUMBER
	MOVSI AC1,400000	; PUT A BIT IN THE CONSOLE SELECT POSITION
	LSH AC1,-=12(TAC)	; PUT IT IN THE RESET PART FIRST
	ANDCAM AC1,DPYAVL+1	; DON'T RESET US
	ANDCAM AC1,WHOSEL	; DON'T RESET US FOR WHOLINE EITHER
	LSH AC1,=12		; PUT IT IN THE SELECT POSITION
	ORM AC1,DPYAVL+1	; SELECT THIS CONSOLE
	ORM AC1,WHOSEL		; SELECT THIS CONSOLE FOR SYS WHO LINE
	POPJ P,			; BYE NOW.

DPYKFS:	MOVNI AC2,3
IFN FTHDRCHK,< PUSHJ P,HDRCHK > ;See if FS word at end of dpy hdr is ok
	MOVEI AC3,DPYFS
	PUSHJ P,SFSREL		;GIVE BACK SPARE TEXT BLOCKS
	HLRZ DAT,PPCALL(DDB)
	JUMPE DAT,DPYKF2	;NO PAGE PRINTER
DPYKF1:	MOVE AC1,FBLKPT(DAT)
	PUSHJ P,FREEL		;RELEASE TEXT BLOCKS
	HRRZ AC1,PTB(DAT)
	JUMPE AC1,.+2
	PUSHJ P,FSGIVE		;& LINE POINTER TABLE
	MOVE AC1,DAT
	HRRZ DAT,LINK(DAT)	;GET POINTER TO NEXT P. OF P.
	PUSHJ P,UGIVFS		;BECAUSE THIS ONE'S GOING AWAY
	JUMPN DAT,DPYKF1	;KEEP GOING IF MORE
DPYKF2:
IFN FTDM,<
	SKIPE AC1,DMFS(DDB)
	PUSHJ P,FSGIVE		;Return any special FS used by DM
>;FTDM
	MOVEI AC1,(DDB)
	JRST UGIVFS		;NOW RETURN HEADER
;DPYKI9 DPYKI7 DPYKER DPYK9
; WE GET HERE TO PLANT ANOTHER CLOCK REQUEST TO COME BACK
; LATER TO TRY AND KILL THE DAMN THING.

DPYKI9:	SETZM LEACT(AC1)	; CLEAR THE ACTIVE FLAG
↑DPYK9:	MOVEI AC3,=15*=60	;WAIT 15 SECONDS BEFORE KILLING DPY
	HLLZ AC2,PRGNUM(AC1)	;Get display-type bit or DD channel
	TLNE AC2,DMLIN
	MOVEI AC3,5*=60		;Wait only 5 seconds on DM
	TLOA AC3,DPYKIL
DPYKI7:	MOVE AC3,[DPYKIL,,1]	;Wait one tick and check again
	SETO AC2,		; SET FLAG SAYING THERE IS A CLOCK REQUEST IN
	EXCH AC2,LECLIN(AC1)
	JUMPL AC2,CPOPJ		; IF THERE ALREADY IS A CLOCK REQUEST IN, DON'T BOTHER TO SET ANOTHER
	LSH TAC,=12		; SHIFT LINE NUMBER OVER TO DATA POSITION
	TLZE TAC,1		; DOES LINE NUMBER FIT IN 6 BITS? (SORRY 'BOUT THAT)
	HRLI AC3,DPYKL0		; NO, GET 6 BITS FROM QUEUE AND TURN 100 ON OURSELF
	ADD TAC,AC3		; HAVE US COME BACK HERE IN 1 TICK
	CONO PI,PIOFF
	IDPB TAC,CLOCK(PID)
	CONO PI,PION
	POPJ P,

; THIS ROUTINE PRINTS AN ERROR MESSAGE WHEN THE GIVEN
; LINE NUMBER IS NOT A DISPLAY

DPYKER:	PUSH P,TAC		; SAVE THE ILL NUMBER
	PUSHJ P,DISERR		; GIVE OUR ERROR MESSAGE
	[ASCIZ /NON-DISPLAY LINE NUMBER AT DPYKILL - /]
	DISARG OCT,<-1(P)>
	[ASCIZ /
/]
	-1
	POP P,TAC
	POPJ P,
;DPYINT NOSTOP L6 L5 L3 DPYXIT

; HERE ARE THE INTERRUPT ROUTINES FOR RUNNING THE DP.

↑DPYINT:	BEGIN DPYINT

DP←←430		;DEVICE NO. OF DISPLAY PROCESSOR.
DPYCHL←<FOR @$ QQ←DPYCHN,DPYCHN {CH$QQ}>	;PI CHANNEL 3 IS WHERE IT'S AT.
DPCONB←←40	;THE `CONTINUE' BIT FOR THE  DP.
DPNULL←←0
DPNXM←←2000	; THE NON-EX MEM BIT
DPINT←←4000	; INTERRUPT REQUEST
DPSTOP←←200	; SET NOT RUNNING
DPCHK←←400	; ERROR CHECK FLAG

	CONSO DP,400000		;IS IT REALLY STOPPED ?
	JRST DPYXIT		;NO. 
	EXCH TAC,DRUNCT		;GET NO. OF DPY WHICH HAS BEEN ON.
	SKIPN STPTBL(TAC)	; STOP HIM HERE ONLY IF HE HAS A STOP TABLE
	JRST NOSTOP
	DATAO DP,STPTBL(TAC)	;STOP DP AT RIGHT PRGM HEADER.
	MOVEM TAC1,@SELTBL(TAC)
	CONI DP,TAC1		;SAVE CURRENT SELECTION FOR NEXT TIME
	HRRI TAC1,DISSEL
	EXCH TAC1,@SELTBL(TAC)
NOSTOP:	CONSZ DP,DPNXM!DPCHK	; HIT A NON-EX MEM OR ERROR CHECK?
	JRST DPERR		; YES, PROCESS IT
L6:	SOJL TAC,L1		;NEXT PRGM TO RUN. (6 PRGMS ALWAYS ARE RUNNING)
L5:	CONSO DP,400000		;MAKE SURE HE FINISHED STOPPING
	JRST L5
	SKIPE RSTTBL(TAC)	;DOES HE WANT TO START FROM THE FRONT ?
	JRST L2			;YES.
	SKIPN STRTBL(TAC)	; IS THERE A PROGRAM THERE?
	JRST L7
	DATAO DP,STRTBL(TAC)	;NO.  START HIM AT NORMAL PLACE.
L3:	EXCH TAC,DRUNCT		;PUT THINGS BACK.
	ROT 44
	CONO DP,DPCONB+DPYCHN+740000+1000	;START DP AND CLEAR MASKS.
DPYXIT:	JEN @DPYCHL		;RETURN TO WHOMEVER.
;DPERR ADDRCK NOADDR NODPLK L8 L9

;HERE WE HAVE AND ERROR - - PRINT A MESSAGE AND CHECK THE SYSTEM!
DPERR:	EXCH P,APRPDL+P1PID	; GET A STACK
	PUSHACS			; GET US SOME AC'S
	MOVEI PID,P1PID
	MOVEM TAC,SAVTAC		;SAVE DP #
	CONI DP,DPCNI		;GET SOME BITS
	PUSHJ P,DISDATE
	PUSHJ P,DISERR
	[ASCIZ/DP ERROR.
CONI BITS = /]
	DISARG LOC,DPCNI
	[ASCIZ/
DPY# = /]
	DISARG LOC,SAVTAC
	-1
	MOVE AC3,SAVTAC
	SKIPN AC3,STPTBL(AC3)
	JRST NOADDR
	HLRZS AC3
	HLRZ AC3,(AC3)		;GET MA
	PUSHJ P,DISERR
	[ASCIZ/    MA = /]
	DISARG LOC,AC3
	[ASCIZ/
/]
	-1
	CAILE AC3,1
	CAMLE AC3,RMEMSIZ	;IS IT LEGAL?
	JRST ADDRCK
	PUSHJ P,DISERR
	[ASCIZ\MA-2/   \]
	DISARG OCT,-2(AC3)
	[ASCIZ\
MA-1/   \]
	DISARG OCT,-1(AC3)
	[ASCIZ\
MA/     \]
	DISARG OCT,(AC3)
	-1
	JRST NOADDR
ADDRCK:	PUSHJ P,DISMES
	ASCIZ/NON-EX ADDRESS/
NOADDR:	PUSHJ P,DISMES
	ASCIZ/


/
	PUSHJ P,SYSFIX		;CHECK SYSTEM FOR CLOBBERING
	JFCL			;OK
	JFCL			;NOT OK
	SKIPN DEBMOD		;DOES HE WANT TO LOOK AT IT?
	JRST NODPLK		;NO
	PUSHJ P,DISFLUSH	;FORCE OUT THE REST
	PUSHJ P,DDTCALL		;AND CALL DDT
NODPLK:
	MOVEI TAC,DPYNUM-1	;RESTART ALL DISPLAYS
L8:	SKIPN DDB,LETAB+DPYL0(TAC)
	JRST L9			; IF NONE THERE, LOOP
	HRLI DDB,PSELB(DDB)	; ARRANGE TO RESTART AT TOP AGAIN
	HRRI DDB,DISJMP
	MOVEM DDB,RSTTBL(TAC)
L9:	SOJGE TAC,L8		; GET THEM ALL!
	POPACS			; GET BACK AC'S
	EXCH P,APRPDL+P1PID	; AND WHATEVER WAS IN P
	JRST L6			; AND DO NEXT GUY
;L2 L1 L1A L4 L7

; DP INTERRUPT CODE - RESTART PROGRAM, LOOP AROUND OF NEXT DPY, STOP DP, SET AVAILABLE MESSAGE

L2:	DATAO DP,RSTTBL(TAC)	;START GUY AT BEGINNING OF HIS PRGM.
	SETZM RSTTBL(TAC)	;...THIS TIME ONLY.
	JRST L3

L1:	SKIPE DPYHOL		; HAS THE HOLDING MESSAGE GONE OUT YET?
	JRST L1A		; YES, CONTINUE WITH OUR BUSINESS
	SETOM DPYHOL
	DATAO DP,[XWD DPYHLD,DISJMP]
	JRST L3

L1A:	SETZM DPYHOL
	MOVEI TAC,DPYNUM-1	;WE'VE RUN `EM ALL.
	SETZM DPYARN		; NOTE THAT THEY HAVE ALL BEEN RUN
	AOSE DSFLAG		;HAS CLOCK TICKED ?
	AOJA TAC,L4		;NO. IT'S NOT YET TIME TO START OVER.
	JRST L5

L4:	CONO DP,DPNULL		;SHUT DOWN THE DP.
	EXCH TAC,DRUNCT
	JRST DPYXIT

L7:	SKIPE DPYARN		; HAS THE 'CONSOLE AVAILABLE' MESSAGE GONE OUT YET?
	JRST L6			; YES
	SETOM DPYARN		; NO, IT WILL.
	DATAO DP,[XWD DPYAVL,DISJMP]
	JRST L3			; GO START UP DP AND LEAVE

BEND
;PPINIT		PAGE PRINTER STUFF

COMMENT  ⊗	THIS IS THE ABODE OF THE FEARSOME PAGE PRINTER.
	IT ALLOWS EACH LUCKY USER (IF HE IS OBEDIENT) TO HAVE
	UP TO 16 PIECES OF PAPER (OR REASONABLE FACSIMILE
	THEREOF), ON ANY OF WHICH HE CAN TYPE AND DRAW IN
	DIVERSE WAYS, AND WHICH CAN BE ROLLED BACKWARD AND
	FORWARD AND DISPLAYED SEPARATELY OR IN ARBITRARY
	COMBINATION WITH OTHER DISPLAYS.
		EACH PIECE OF PAPER CONSISTS OF A LINKED
	SET OF BLKS FROM FREE STORAGE AND ONE CONTROL BLOCK,
	ALSO FROM FREE STORAGE. THE CONTROL BLOCK IS LINKED
	TO THE PROGRAM HEADER AND TO THE CONTROL BLOCKS FOR ANY
	OTHER PIECES OF PAPER BELONGING TO THE SAME PROGRAM.
⊗

OUTNUM←←1	;THIS MANY BLOCKS AT ONCE GET PUT ON DISK.
LINELN←←=88	;NO. OF CHARS. PER LINE.
DDLINELN←←=84	; SAME AS ABOVE FOR DATA DISK
DMLINELN←←=80	; SAME FOR DATAMEDIA
CBLKBT←←1;	;MAGIC CODE BITS FOR THE (HO, HO) RELOCATING GARBAGE COLLECTOR.
TBLKBT←←4
FBLKBT←←2

;CALL WITH MAIN DD CHANNEL IN TAC, OR IF NOT DD, WITH LINE BITS IN TAC RH (NOTE RH)
↑PPINIT:	   		;INITIALIZE A PAGE PRINTER WITH PIECE OF PAPER 0.
	PUSHJ P,PPFSGET		;GET A BLOCK OF FREE STORAGE.
	POPJ P,			; NO FREE STORAGE, GIVE ERROR RETURN
	HRR AC3,AC2		;MAKE BLT POINTER.
	HRRZ DAT,AC2
	HRLI AC3,PPMODL
	BLT AC3,BLKSIZ-1(AC2)	;INIT THE CONTROL BLK BY COPYING PROTOTYPE INTO IT
	PUSHJ P,PPFSGET		;GET A FREE STORAGE BLOCK FOR FIRST PART OF PRGM
	JRST PPI1		; NO FS, RELEASE PREVIOUS BLKS, TAKE ERROR RETURN
	MOVEM AC2,CBLKPT(DAT)	;MAKE IT CURRENT BLOCK...
	MOVEM AC2,FBLKPT(DAT)	;.. AND FIRST BLOCK IN CORE...
	MOVEM AC2,TBLKPT(DAT)	;... AND TOP BLK BEING DISPLAYED.
	HRRM AC2,PPTR1(DAT)	;MAKE BYTE POINTER FOR TYPING POINT
	SOS PPTR1(DAT)		; ONE BEFORE BOTTOM OF BLOCK.
	HRLM AC2,TPJMP(DAT)	;FIX UP JMP TO PRGM IN CONTROL BLOCK
	HRLI AC3,TPJMP+1(DAT)	;RETURN ADDR FROM PRGM TO CONTROL BLK
	HRRI AC3,DISJMP
	MOVEM AC3,(AC2)		;PUT RETURN JMP IN FIRST WORD OF PRGM.
	HRLZM DAT,LINK(AC2)	;BACKWARD LINK OF PRGM POINTS TO CONTROL BLOCK
	SETZM LINK(DAT)		;ONLY ONE CONTROL BLOCK.
;PPXFT PPI3 PPI1

	MOVE AC3,[DDDLIN,,POSLDD]
	TRNE TAC,DISLIN
	MOVE AC3,[DISLIN,,POSLII]
	TRNE TAC,DMLIN
	MOVE AC3,[DMLIN,,POSLDM]
	MOVEM AC3,PPDPY(DAT)	; STORE BITS FOR DISPLAY TYPE AND POSLIN SUBROUTINE
	MOVEI AC3,LPFS		; GET SOME FREE STORAGE FOR THE
	PUSHJ P,SFSGET		; LINE POINTER TABLE
	JRST PPI3
	MOVEM AC1,PTB(DAT)	; SAVE ADDRESS OF BEGINNING OF BLOCK
	ADDI AC1,=20		; BUMP ADDRESS TO VISIBLE SCREEN PART
	HRRM AC1,PTRB(DAT)
	MOVE AC2,PPTR1(DAT)	; INITIALIZE FIRST WORD OF POINTER TABLE
;	ADD AC1,VPOS(DAT)	; GET ADDRESS OF FIRST POINTER TO BE USED
	ADDI AC1,3		;I don't know why it used VPOS which came from model
	MOVEM AC2,(AC1)		; TO POINT TO FIRST OF TEXT
	MOVEM AC2,1(AC1)	; SAME FOR DD
	TRNE TAC,DISLIN
	JRST PPFXT		;DONE FOR III
	MOVEI AC1,NLSDD		; DEFAULT NUMBER OF LINES/GLITCH FOR DD
	TRNE TAC,DMLIN
	MOVEI AC1,NLSDM		; DEFAULT L/G FOR DM
	MOVEM AC1,DEL(DAT)
	MOVEM AC1,DELCNT(DAT)
	MOVEI AC1,NGSDD		; DEFAULT NUMBER OF GLITCHES/SCREEN FOR DD
	TRNE TAC,DMLIN
	MOVEI AC1,NGSDM		; DEFAULT G/S FOR DM
	MOVEM AC1,PGSIZ(DAT)	; 32 LINES TO A SCREEN AND DON'T DO A WHOLE PAGE REFRESH TOO OFTEN
	MOVEI AC1,4		;Start on line 4, goddammit
	MOVEM AC1,VPOS(DAT)
	MOVEM AC1,LLW(DAT)
	MOVEM AC1,GLW(DAT)
	SETZM DDSAV(DAT)	; CLEAR EXTRA SAVED WORDS
	MOVE AC1,[CW 1,46,2,0,3,2]
	DPB TAC,[POINT 8,AC1,15]
	MOVEM AC1,DDCW(DAT)
	MOVEI AC2,DDLINELN	; SET OUR OWN LINE LENGTH
	TRNE TAC,DMLIN
	MOVEI AC2,DMLINELN	; DM LINE LENGTH
	MOVEM AC2,LNLNGT(DAT)
	MOVNM AC2,DPHPOS(DAT)	; INITIALIZE THE HORIZONTAL POSITION COUNTER
	MOVE AC1,[LVW -777,YPDD,I,A,2,2]
	TRNE TAC,DMLIN
	MOVE AC1,[LVW -777,YPDM,I,A,2,2]
	MOVEM AC1,PPOSV(DAT)
	SETZM TPJMP+1(DAT)
	SETZM TPJMP+2(DAT)
	MOVE AC1,[CW 3,2,4,0,5,0]
	MOVEM AC1,TPJMP+4(DAT)
PPFXT:	MOVE AC1,DAT
	JRST CPOPJ1

; WE GET HERE MOSTLY IF A REQUEST FOR FREE STORAGE FOR THE PAGE PRINTER FAILS

PPI3:	HRRZ AC1,CBLKPT(DAT)	; RETURN FIRST PIECE OF TEXT
	PUSHJ P,FSGIVE
PPI1:	HRRZ AC1,DAT		; AND RELEASE CONTROL BLOCK ITSELF
	PUSHJ P,FSGIVE		; TAKE ERROR RETURN FROM PPINIT
	POPJ P,			; PLEASE DON'T OPTIMIZE!
;PPFSGE CGETFS UGFS2 UGETFS CGIVFS UGIVFS GETQ UGETF2 UGETF1
; FREE STORAGE HANDLER FOR PAGE PRINTER

PPFSGE:	MOVE AC2,AC1
	MOVEI AC3,PPFS
	AOS (P)
	PUSHJ P,SFSGET
	SOS (P)
	EXCH AC2,AC1
	POPJ P,

;;UGETFS IS FOR GETTING FREE STG. AT UUO LEVEL.

CGETFS:	AOSA BLKTOT(DDB)
UGFS2:	PUSHJ P,CLKWAT		;WAIT FOR SOME FS TO APPEAR.
↑UGETFS:			;;GET A BLOCK OF FREE STG. FROM JAM.
	MOVEI AC3,DPYFS
	PUSHJ P,SFSGET
	SKIPE AC1,SPWUUF(PID)	;WE ARE AT CLOCK LEVEL AND THERE'S NO FREE STG.
	POPJ P,
	SKIPN AC1,INTACT(PID)	; OR AT USER INTERRUPT LEVEL
	JRST UGFS2		;OOPS, NONE THERE, AND WE ARE NOT IN SPACEWAR MODE.
	POPJ P,

; ROUTINE TO RELEASE FREE STORAGE BLOCKS

CGIVFS:	SOS BLKTOT(DDB)		;DECR. COUNT OF USED BLOCKS...
↑UGIVFS:
	CONO PI,PIOFF
	MOVE AC2,FSWT2H		;FREE THE BLOCK IN AC1.
	HRRZM AC1,FSWT2H
	HRRM AC2,LINK(AC1)
	CONO PI,PION
	AOS FSW2C
	POPJ P,

;GET A DD Q BLOCK
↑GETQ:	PUSH P,AC3
	MOVE AC3,[SETZ DDFS]	;NO SKIP
	PUSHJ P,SFSGET
	POP P,AC3
	POPJ P,

UGETF2:	PUSHJ P,CLKWAT
UGETF1:	PUSHJ P,FSGET
	SKIPE AC1,SPWUUF(PID)	;TOO BAD WE HAVE TO DUPLICATE ALL THIS SHIT
	POPJ P,
	SKIPN AC1,INTACT(PID)
	JRST UGETF2
	POPJ P,
;BELOW IS THE PROTOTYPICAL P. OF P. CONTROL BLOCK.

DEFINE X (A,B) {A←←.-PPMODL
		B
		}
PPMODL:  

X PPOSV,{LVW  -777,YPIII,I,A,2,2}	;POS VECTOR
X ↑TPJMP, DISJMP	;JMP TO FIRST BLOCK OF PAGE BEING DISPLAYED.
	LVW (7,-17,I)	;NOW DRAW THE CURSOR.
	LVW -5,-10
X ↑DDCW,<LVW 12,0>
	LVW -5,10
	LVW (-7,7,I)
X ↑PPRJMP, DISJMP	;JMP BACK TO HEADER OR ON TO NEXT CONT. BLK.

X HEDPTR,0		;POINTER BACK TO PRGM HEADER.
X OUTCNT,OUTNUM		;BLOCKS REMAINING BEFORE DISK OUTPUT.
X ↑PPNO,0		;NONO. OF THIS P. OF P.
X ↑DPHPOS,-LINELN	;CHARS. LEFT BEFORE END OF THIS LINE.
X CNT1,0		;CHARS. REMAINING  BEFORE EXTENSION NEEDED.
X PPTR1,{POINT 7,0,35}	;CURRENT POINTER FOR PRINTING ON THIS PIECE OF PAPER.
X SPTR1,0		; SAVED POINTER FOR ZEROING OUT SPACE BEFORE CR
X WCNT,-INITWC		;FREE WORDS LEFT IN CURRENT BLOCK.
X CBLKPT,0		;BOTTOM OF CURRENT BLOCK.
X ↑TBLKPT,0		;FIRST BLOCK CURRENTLY DISPLAYED (AT TOP OF SCREEN)
X FBLKPT,0		;FIRST BLOCK STILL IN CORE.
X DEL,2			; NO. OF LINES IN A GLITCH.
X DELCNT,2		;LINES REMAINING IN CURRENT GLITCH.
X GLCNT,1		;CURRENT SIZE OF PAGE IN GLITCHES.
X PGSIZ,14		;NOMINAL SIZE OF PAGE IN GLITCHES.
X PTBEG,0		; INCREMENT INTO LINE POINTER TABLE
X DDSPT,0		;POINTS TO SAVED WORD FROM FIRST REFRESHED LINE (DD)
X DDSAV,0		;SAVED WORD FROM FIRST REFRESHED LINE (DD)
	0
X (↑VPOS,3)		;LINE NUMBER OF CURRENT LINE
X LLW,3			; LAST LINE WRITTEN
X PTRB,<XWD AC3,0>	;POINTS TO TABLE OF BYTE POINTERS TO THE FIRST OF EACH LINE (DD)
X PTB,0			; ACTUAL TABLE ADDRESS
X VP,0			; VERTICAL POSITION ARGUMENT TO QDD
X SC,0			; ARGUMENT TO QDD FOR COUNT FIELD ADDRESS
X DPYCHR,0		; FLAG SAYING AT LEAST ONE CHARACTER HAS BEEN TYPED
X LSTCHR,12		; LAST CHARACTER DEPOSITED INTO BUFFER
X GLW,3			; GREATEST LINE WRITTEN, FOR ERASING WHEN WE GLITCH
X ↑PPDPY,0		; LH IS BIT TELLING DISPLAY TYPE, RH IS POSLIN SUBROUTINE
X GLTCH,0		; FLAG THAT SAYS THE PAGE PRINTER HAS GLITCHED
X PPINV,0		; FLAG INDICATING PAGE PRINTER POINTERS ARE BEING MODIFIED
X PPENQ,0		; NUMBER OF TASKS THIS PAGE PRINTER HAS IN THE DD QUEUE
X PPNQT,0		; COUNT DOWN FOR NON-PAGE PRINTER REQUESTS
X PPVIRG,-1		; INDICATES VIRGIN PAGE PRINTER
IFN FTDM,<
X DMLAST,0		;Byte pointer to last character queued from this PP
X DMPPXY,0		;X-Y position for next char output on this PP
X DMGLCH,0		;Number of DM glitches needing to be queued for this PP
>;FTDM
X ↑LNLNGT,LINELN	;LINELENGTH FOR THIS GUY.
;Don't put any cells after LNLNGT as BLKSIZ is defined below from LNLNGT.

; ALL DISPLAY PROGRAM SPACE IS TAKEN FROM A FREE
;  STORAGE AREA CONSISTING OF FIXED SIZE BLOCKS.  THE
; FOLLOWING PARAMETERS RELATE TO THOSE BLOCKS.

↓BLKSIZ←←<<LNLNGT+5+1>!<TRIVIAL-1>>-1	;BLOCK SIZE. THIS IS ARBITRARY, BUT ≥36
↑BLKSIZ←←BLKSIZ
↓LINK ←← BLKSIZ-1	;LINKS IN LAST WD OF BLK: XWD BACK,FORWARD
↓BLKBTS ←← LINK-1	;MAGIC TYPE BITS FOR BLK GO HERE.
↓GCINFO ←← BLKBTS-1	;INFO FOR THE (HYPOTHETICAL) GARBAGE COLLECTOR
FSBSIZ←←BLKSIZ-2	;BLKSIZ FOR OUTSIDE WORLD.
↑FSLINK←←LINK
↓CNT←←GCINFO-2		;MAX. NO. OF `GLITCHES' PER PAGE.
INITWC←←GCINFO-2	;THIS MANY WORDS/BLOCK AVAILABLE FOR PROGRAM.
;DTYO DPYTYO TYO0 TYO5 TYO1 TYO2 TYO7 TYO4 DELNOW

;DTYO--CHARACTER IN CHR, DAT POINTS TO P.OF P. CONTROL BLOCK.
;DPYTYO IS CALLED FROM LINED TO ECHO INPUT CHARACTERS AND THEIR CONTROL BITS
;DTYO IS CALLED FROM DPYTYP AT CLOCK LEVEL WITH A CHARACTER FROM THE OUTPUT BUFFER

;THESE ROUTINES PLACE CHARACTERS IN THE DISPLAY'S PIECE OF PAPER TEXT BLOCKS
;DDB MUST POINT TO DPY HEADER

↑↑DPYTYO:
	MOVE	DAT,CURPP(DDB)	; PICK UP POINTER TO PAGE PRINTER CONTROL BLOCK
	HLL	DAT,DDB		; PUT IN DISPLAY BITS
↑DTYO:	MOVE	AC1,LSTCHR(DAT)	; PICK UP LAST CHARACTER TYPED
	TLNN	DAT,DDDLIN
	JRST	.+3
	CAIN	AC1,177		; LAST CHAR A DELETE ON A DD?
	JRST	DELNOW		; YES, <DELETE><CHR> IS A SINGLE NORMAL GRAPHIC.
	JUMPE	CHR,CPOPJ	;DON'T PRINT NULLS.
	JUMPGE	AC1,TYO0	;JUMP UNLESS THE LAST THING WE DID WAS INVENT CRLF.
	CAIN	CHR,15		;A CR AFTER WE INVENTED A CRLF?
	POPJ	P,		;YES. SUPPRESS IT.
	MOVEI	AC1,12		;MAKE IT LOOK LIKE THE LAST CHARACTER WAS LF.
	MOVEM	AC1,LSTCHR(DAT)	;SET IT.
	CAIN	CHR,12		;CHARACTER IS LF?
	POPJ	P,		;YES. SUPPRESS THAT TOO.
				;NOW IT LOOKS LIKE NORMAL CHARACTER, LSTCHR SET.

TYO0:	SETOM DPYCHR(DAT)	; NOTE THAT ANOTHER CHARACTER HAS BEEN PUT INTO PP
	CAIN CHR,15		; IS IT A CR ?
	JRST PR1ECR		; YES, GO SERVICE IT
	JUMPL DAT,TYO1		; IF III, WE CAN SKIP ALL THIS BULLSHIT
	CAIE AC1,12		; WAS LAST CHARACTER A LF?
	JRST TYO1		; NO
;ON DD OR DM, FIRST CHARACTER AFTER LF
	MOVE AC1,DPHPOS(DAT)	; WELL, ARE WE AT THE BEGINNING OF THE LINE?
	ADD AC1,LNLNGT(DAT)
	JUMPE AC1,TYO4		; YES, THERE MUST HAVE BEEN A CR FIRST.
	PUSH P,CHR		; SAVE OUR CHARACTER
	PUSH P,AC1		; SAVE THE COUNT (I.E., COLUMN NUMBER.)
	SETZ CHR,
	DPB CHR,SPTR1(DAT)	; REPLACE LF WITH NULL
	MOVEI CHR,15
	PUSHJ P,PUT2CH		; Put in CR, making sure there is room for LF
	MOVEI CHR,12		; PUT OUR LF BACK
	SOS VPOS(DAT)
	PUSHJ P,PUTCH1
	PUSHJ P,EOLSET		; STORE THE POSITION OF OUR NEW LF
	MOVEI CHR,40		; THEN PAD OUT THE LINE
;TYPE A BUNCH OF SPACES TO SIMUALTE A BARE LINE FEED.
TYO5:	PUSHJ P,PUTCH1		;SEND A SPACE.
	SOSLE (P)		;DECREMENT THE SPACE COUNT.
	JRST TYO5		;LOOP SPACING.
	SUB P,[1,,1]		;ADJUST STACK TO REMOVE SPACE COUNT.
	POP P,CHR		;RESTORE CHARACTER. FALL INTO TYO1

TYO1:	CAIN CHR,12		; OR A  LINE FEED ?
	JRST PR1EOL		;YES.
	JUMPL DAT,TYO2		; IF III, JUST PUT THE CHARACTER IN THE BUFFER
	MOVE AC1,DPHPOS(DAT)	; ARE WE AT THE LEFT MARGIN?
	ADD AC1,LNLNGT(DAT)
	JUMPN AC1,TYO2		; NO
	MOVE AC1,LSTCHR(DAT)	; YES, WAS LAST CHARACTER A LF?
	CAIN AC1,12
	JRST TYO2
	PUSH P,CHR		; NO, PUT ONE IN!
	MOVEI CHR,12
	PUSHJ P,PUTCH1
	PUSHJ P,EOLSET		; STORE LINE POINTER
	SOSG DELCNT(DAT)	; TIME TO GLITCH YET?
	PUSHJ P,PREOGL		; YES, DO IT.
	POP P,CHR
TYO2:	CAIN CHR,11		; TAB?
	PUSHJ P,PR1TAB		; YES, GO EXPAND IT.
	PUSHJ P,PUTCH1		; PUT CHARACTER INTO BUFFER
TYO7:	MOVEM CHR,LSTCHR(DAT)	; SAVE LAST CHARACTER
	TLNN DAT,DDDLIN
	JRST .+3
	CAIN CHR,177		;IS THIS A DELETE?
	JRST .+3		;YES. FOR DD AVOID CHANGING THE H.POSITION.
	AOSL DPHPOS(DAT)	;UPDATE HORIZONTAL POS.
	JRST PRCR		;OVER END OF LINE..  INSERT CR LF.
	MOVE AC1,[CW 0,0,3,2,3,2]
	TLNE DAT,DDDLIN		; IF WE ARE A DD
	MOVEM AC1,TPJMP+1(DAT)	; AND THE LINE DOESN'T END WITH CRLF, PUT IN AN EXECUTE
	POPJ P,

;DD. LAST CHARACTER WAS A DELETE. THIS CHARACTER WILL MAKE AN ORDINARY GRAPHIC.
DELNOW:	PUSHJ P,PUTCH1		;PUT CHARACTER IN BUFFER
	IORI CHR,200		;MAKE IT SPECIAL SO WE WON'T COMPARE EQUAL TO IT
	JRST TYO7

;HERE ON DD OR DM IF THE LAST CHARACTER WAS A LF AND WE ARE AT THE LEFT MARGIN
;CURRENT CHAR IS NOT A CR
TYO4:	CAIE CHR,12		; IS THIS CHARACTER A LF?
	JRST TYO2		; NO, JUST DUMP THE CHARACTER IN THE BUFFER
	PUSHJ P,PR1EC2		; YES, PUT IN A SPACE AND A CR AND A LF
	MOVEI CHR,12		; AND THEN A LF
	MOVEM CHR,LSTCHR(DAT)
	POPJ P,
;PUTCH1 PUT2CH PUT2C2 PUT2C3 PR1TAB PR1TB1 PRCR PRCR2 PRCR3

;WE GET HERE TO PRINT SPACES FOR A TAB
PR1TAB:	SETCM AC1,DPHPOS(DAT)	;GET CURRENT HORIZONTAL POSITION.
	SUB AC1,LNLNGT(DAT)	; MAKE TABS START IN COLUMN 8
	ANDI AC1,7		;GET NO. OF SPACES TO NEXT MULTIPLE OF 8 BOUNDARY.
	ADDM AC1,DPHPOS(DAT)	;UPDATE HIM.
	TLNE DAT,DMLIN		;DATAMEDIA DISPLAY?
	POPJ P,			;YES, IT HAS HARDWARE TABS! (WHICH WE HAVE SET)
	PUSH P,AC1		;PUT COUNT OF EQUIVALENT SPACES ON STACK
	PUSHJ P,PUTCH1		;FIRST PRINT THE TAB.
	MOVEI CHR," "		;NOW OUTPUT RIGHT NUMBER OF SPACES.
PR1TB1:	PUSHJ P,PUTCH1		;NOW EMIT A SPACE.
	SOSL (P)		;..AND SOME MORE, IF APPROPRIATE.
	JRST PR1TB1
	MOVEI CHR,11		;WE WILL FINISH OFF WITH ANOTHER TAB.
	SUB P,[1,,1]		;DISCARD COUNT FROM STACK
	POPJ P,

;STICK A CRLF IN TO BREAK UP LONG LINES
PRCR:	SKIPL WCNT(DAT)		;Any spare words in this buffer?
	JRST PRCR2		;No, see if room for 2 chars in this last word
PRCR3:	MOVEI CHR,15		;PRINT A CR.
	PUSHJ P,PUTCH1
	MOVEI CHR,12		;NOW INVENT A LINE FEED.
	PUSHJ P,SETLL		; RESET DPHPOS
	PUSHJ P,PR1EOL		;GO DO THE END-OF-LINE BIT
	SETOM LSTCHR(DAT)	;FLAG THAT WE INVENTED CRLF HERE.
	POPJ P,			;(DPYTYP WILL WAIT FOR LINE BEFORE SENDING MORE)

;Last char of long line and CRLF must all be in same buffer for DM at least.
PRCR2:	MOVE AC1,CNT1(DAT)	;Get number of bytes left + 1
	CAILE AC1,2
	JRST PRCR3		;Room still for at least 2 more chars
	LDB CHR,PPTR1(DAT)	;Get back last char
	SETZ AC1,
	DPB AC1,PPTR1(DAT)	;And replace it in buffer with a null
	PUSHJ P,PUT2C3		;Get new buffer and stick in last char
	JRST PRCR3		;Now put CRLF into new buffer

;Here to make sure there is room in current buffer for at least 2 chars (CRLF)
PUT2CH:	SKIPL WCNT(DAT)		;Any spare words in this buffer?
	JRST PUT2C2		;No
PUTCH1:	SOSG CNT1(DAT)		;Print CHR without special character checking
PUT2C3:	PUSHJ P,EXTBUF		;GO EXTEND BUFFER, OR GET NEW ONE IF NEEDED
	IDPB CHR,PPTR1(DAT)
	POPJ P,

;We are now in last word of buffer--see if there is room in this word for 2 chars
PUT2C2:	SOS AC1,CNT1(DAT)	;Decrement count of unused room in buffer
	SOJLE AC1,PUT2C3	;Jump if not enough room
	IDPB CHR,PPTR1(DAT)	;Room for at least 2 chars in this word--put in one
	POPJ P,
;PR1ECR PR1EC1 PR1EC3 PR1EC2 PR1EOL PREOGL SETLL

;Here on CR
PR1ECR:	JUMPL DAT,PR1EC1	; IIIs are simple
	TLNE DAT,DDDLIN		; IS THIS A DD?
	SETZM TPJMP+1(DAT)	; YES, LINE ENDS WITH CRLF, SO KILL THE EXECUTE
	MOVEI AC1,12		; WAS THE LAST CHARACTER A LF
	CAME AC1,LSTCHR(DAT)
	JRST PR1EC1
	MOVN AC3,DPHPOS(DAT)	; PICK UP THE HORIZONTAL POSITION
	CAMN AC3,LNLNGT(DAT)	; ARE WE AT THE BEGINNING OF THE LINE?
	JRST PR1EC2		; YES, NO NEED FOR ANY MORE CR'S, BUT PUT IN SPACE
	SOS VPOS(DAT)
	SETZ AC1,
	DPB AC1,SPTR1(DAT)	; Put a NULL in over the LF
	PUSHJ P,SETLL		; RESET DPHPOS
	MOVEI CHR,15
	PUSHJ P,PUT2CH		; Put in CR, making sure there is room for LF
	MOVEI CHR,12
	PUSHJ P,PUTCH1		; STICK THE LF IN
	MOVEM CHR,LSTCHR(DAT)	; SAVE IT
	JRST EOLSET		; DO THE END-OF-LINE BIT

;Here on CR after non-LF
PR1EC1:	MOVN AC3,DPHPOS(DAT)	; NOW (SIGH) SEE IF WE ARE AT THE LEFT MARGIN!
	CAMN AC3,LNLNGT(DAT)
	POPJ P,			; IF SO, FLUSH THIS CR
	PUSHJ P,SETLL		; RESET DPHPOS
PR1EC3:	PUSHJ P,PUT2CH		; Put in the CR, making sure there is room for LF
	SETOM LSTCHR(DAT)	; Flag that we invented a LF
	MOVEI CHR,12
	JRST PR1EO2

; WE GET HERE IF THE LAST CHARACTER WAS A LF AND WE ARE AT THE LEFT MARGIN
PR1EC2:	MOVEI CHR,40		; PRINT A SPACE SO THE LINE WILL GET ERASED
	PUSHJ P,PUTCH1
	MOVEI CHR,15
	JRST PR1EC3

; HERE ON LF
PR1EOL:	TLNE DAT,DDDLIN		; IS THIS A DD?
	SETZM TPJMP+1(DAT)	; YES, NO NEED FOR AN EXECUTE AT END OF BUFFER
	MOVEM CHR,LSTCHR(DAT)	; SAVE THIS CHARACTER
PR1EO2:	PUSHJ P,PUTCH1		;PUT IN LF
	PUSHJ P,EOLSET		;SET VERTICAL POSITION AND SAVE BYTE PTR
	SOSLE DELCNT(DAT)	;ARE WE AT THE TOP OF A GLITCH ?
	POPJ P,			;NO. GO BACK.
PREOGL:	MOVE AC3,DEL(DAT)	;GET NO. OF LINES PER GLITCH..
	MOVEM AC3,DELCNT(DAT)	;.. AND INIT. THE COUNT.
	AOS AC1,GLCNT(DAT)	;UPDATE SIZE OF PAGE.
	CAMG AC1,PGSIZ(DAT)	;IS IT TOO BIG ?
	POPJ P,			; NOT YET.
	JRST GLITCH		; YES, MOVE IT UP SOME

;INITIALIZE LENGTH OF THE LINE AT CR.
SETLL:	MOVN AC1,LNLNGT(DAT)	;GET -LINELENGTH.
	MOVEM AC1,DPHPOS(DAT)	;RESET HORIZONTAL POS.
	POPJ P,
;EXTBUF L2 L1 GBLK

BEGIN EXTBUF	;MAKE MORE ROOM IN THE DISPLAY BUFFER.

↑EXTBUF:
	EXCH AC1,PPTR1(DAT)	;GET BYTE POINTER.
L2:	MOVN AC2,WCNT(DAT)	;HOW MANY WORDS LEFT IN THIS BLOCK ?
	JUMPE AC2,GBLK		;IF NONE, GET A NEW BLOCK.
	CAILE AC2,10		;IF FEWER THAN 8, USE THAT  NO.
	MOVEI AC2,10		;..ELSE USE 8 WORDS.
	ADDM AC2,WCNT(DAT)	;DECREMENT THE COUNT.
	MOVE AC3,AC2
	ASH AC3,2		;MULTIPLY BY 5 RAPIDLY.
	ADD AC3,AC2
	MOVEM AC3,CNT1(DAT)	;THAT'S THE NEW CHAR. COUNT, FOLKS.
	MOVE AC3,1(AC1)		;PICK UP THE JMP AT CURRENT END OF BUFFER..
	ADDI AC1,1(AC2)		;GET NEW POS. FOR IT...
	MOVEM AC3,(AC1)		;.. AND PUT IT THERE.
	MOVEI AC3,1		;MANUFACTURE A NULL CHAR. WORD...
L1:	SUBI AC1,1		;AND FILL THE NEWLY AVAILABLE AREA OF THE
	MOVEM AC3,(AC1)		;BUFFER WITH IT.
	SOJG AC2,L1
	SUBI AC1,1
	TLZ AC1,760000		;BUG FIX REG RPH 24 JUL 72
	EXCH AC1,PPTR1(DAT)	;RESTORE THINGS TO THEIR RIGHTFUL PLACES.
	POPJ P,

GBLK:  ;;GET ANOTHER BLOCK FROM FREE STORAGE FOR PRGM.
	AOSLE BLKTOT(DDB)	;INC. HIS COUNT OF BLOCKS USED.
	PUSHJ P,FBLK		;OOPS, TOO MANY. FREE SOME.
	PUSHJ P,GETFS		;GET ANOTHER BLOCK FROM FREE STORAGE.
	HRR AC1,AC2		;MAKE THE BYTE PTR. POINT THERE.
	EXCH AC2,CBLKPT(DAT)	;UPDATE CURRENT BLK. PTR (AND GET OLD ONE).
	MOVEI AC3,CBLKBT	;GC BIT FOR `CURRENT PP BLOCK'...
	ANDCAM AC3,BLKBTS(AC2)	;..TURN IT OFF IN OLD BLOCK.
	MOVEM AC3,BLKBTS(AC1)	;.. AND PLACE IN NEW ONE.
	MOVE AC3,GCINFO(AC2)	;GIVE NEW BLK. SAME GC CODE AS
	MOVEM AC3,GCINFO(AC1)	; OLD ONE.
	MOVNI AC3,INITWC	;SET UP NO. OF FREE WORDS IN NEW BLOCK.
	MOVEM AC3,WCNT(DAT)
	MOVE AC3,INITWC(AC2)	;PICK UP RETURN JMP FROM END OF OLD BLK..
	MOVEM AC3,(AC1)		;.. AND PUT IN FIRST WORD OF NEW ONE.
	HRRM AC1,LINK(AC2)	;MAKE FORWARD LINK OF OLD ONE POINT AT NEW ONE.
	HRLM AC1,INITWC(AC2)	;MAKE JMP AT END OF OLD ONE POINT AT NEW ONE.
	HRLZM AC2,LINK(AC1)	;BACKWARD LINK OF NEW ONE TO OLD ONE...
	SOJA AC1,L2		;JIGGLE NEW BYTE PTR. A BIT AND PROCEDE.

BEND EXTBUF.
;GLITCH GLTCH3 PR1EL4 ADJSIZ CNTWRP GLTCH4 GLTCH0

; WE GET HERE UPON GLITCHING.
; IN THIS CASE, WE SEE IF THERE ARE ANY BLOCKS ABOVE THE
; CURRENT SCREEN. IF SO, WE CAN FREE THEM UP.

GLITCH:	SOS GLHCNT(DDB)		; BUMP COUNT OF GLITCHES TO GO UNTIL HOLD
IFN FTDM,<
	TLNE DAT,DMDLIN
	AOS DMGLCH(DAT)		; Count number of glitches to do on DM later
>;FTDM
	MOVN AC3,DEL(DAT)	; MOVE POINTERS DOWN BY THIS AMOUNT
	SETOM GLTCH(DAT)	; MARK THE FACT THAT WE HAVE GLITCHED
	SETOM PPINV(DAT)	; NOTE THAT POINTERS ARE BEING CHANGED
	ADDM AC3,VPOS(DAT)	; UPDATE VERTICAL POSITION BY NUMBER OF LINES IN GLITCH
	PUSHJ P,PTMOVE		; MAGIC CIRCULAR ROUTINE
	SETZM PPINV(DAT)	; POINTERS ARE OK NOW
GLTCH3:	PUSHJ P,POSLIN		; PICK UP LINE NUMBER OF TOP OF PAGE
	CAMLE AC3,VPOS(DAT)	; IS THERE ANYTHING ON THE SCREEN AT ALL?
	MOVE AC3,VPOS(DAT)	; NOT YET, USE LAST POSITION WRITTEN IN
	PUSHJ P,GLNADR		; GET ADDRESS OF TEXT
	HRRZ AC1,TBLKPT(DAT)	; PICK UP THE POINTER TO THE CURRENT FIRST PAGE
	HRRZI AC3,BLKSIZ-1(AC1)	; GET ADDRESS OF END OF THAT BLOCK
	CAIL AC2,(AC1)		; NOW, ARE WE INSIDE THAT FIRST BLOCK?
	CAILE AC2,(AC3)
	JRST GLTCH5		; NO, FREE UP SOME BLOCKS
	ADDI AC2,1		; MAKE POINTER TO TOP OF PAGE
	HRLM AC2,TPJMP(DAT)	; POINT JUMP TO THERE
PR1EL4:	SOS AC1,GLCNT(DAT)	;IS IT SMALL ENOUGH NOW ?
ADJSIZ: CAMLE AC1,PGSIZ(DAT)
	JRST GLITCH		;NO. GLITCH IT SOME MORE.
	POPJ P,

CNTWRP: MOVEI AC3,CNT		;WRAP A POINTER AROUND THE GLITCH TABLE.
	MOVEM AC3,@-2(AC2)
	JRST (AC2)

GLTCH8:	ONSCN
GLTCH4:	PUSHJ P,PR1FRE		; GO FREE UP AT LEAST ONE
	JRST GLTCH3		; SEE IF WE CAN DO SOME MORE

GLTCH5:	TLNN DAT,DMLIN		;If DM, make sure no queued refs to top block
	JRST GLTCH4
	OFFSCN
	HRRZ AC3,DMPPPT(DDB)	;Examine queued xfers for text block used
	JRST GLTCH6

GLTCH7:	HRRZ AC3,QLINK(AC3)	;Look at next xfer
GLTCH6:	CAIN AC3,DMPPPT-QLINK(DDB)	;End of queue?
	JRST GLTCH8		;Yes
	MOVE AC2,QFLAGS(AC3)	;Get flags for xfer
	TRNN AC2,DMATXY		;Is this a text xfer?
	JRST GLTCH7		;No
	HRRZ AC2,QTAKR(AC3)	;Get address from byte pointer
	CAIL AC2,(AC1)
	CAILE AC2,BLKSIZ-1(AC1)	;Is byte pointer into top block?
	JRST GLTCH7		;No
	ONSCN			;Yes, don't free any blocks this time
	JRST PR1EL4		;Note that DMs don't use TPJMP, so no need to set it
;EOLSET EOLSE2 EOLSE3

; THESE ARE UTILITY ROUTINES USED BY THE PAGE PRINTER
; THIS FIRST ROUTINE IS CALLED AT THE END OF THE LINE THAT
; GOES OFF THE SCREEN ON DATA DISK. WE REPACK THE WORD
; SUCH THAT THE POINTER POINTS TO THE NEXT WORD. THIS WAY
; THE I-LEVEL ROUTINES CAN REPLACE THE ENTIRE WORD WITH
; A JUMP INTO THE PAGE PRINTER CONTROL BLOCK TO KEEP IT
; FROM READING MORE TEXT WHICH WOULD BE OFF THE SCREEN.

EOLSET:	MOVE AC1,PPTR1(DAT)	; PICK UP POINTER TO LF
	MOVEM AC1,SPTR1(DAT)	; SAVE IT
	TLNE DAT,DDDLIN		; ON DD?
	SETZM TPJMP+1(DAT)	; SINCE TEXT ENDS WITH A CRLF, NO EXECUTE IS NEEDED
	LDB AC1,[POINT 6,PPTR1(DAT),5]
	SUBI AC1,1		; ARE THERE ANY SPACES LEFT IN THE WORD?
	IDIVI AC1,7		; THIS GETS NUMBER OF CHARACTERS LEFT IN AC1
	JUMPE AC1,EOLSE3	; IF NONE LEFT, GO ON.
	PUSH P,AC1		; PUT IN THAT MANY NULLS
	SETZ CHR,
EOLSE2:	PUSHJ P,PUTCH1		; FILL OUT WORD WITH NULLS.
	SOSLE (P)		; ENOUGH?
	JRST EOLSE2		; NO, GO DO ANOTHER ONE.
	SUB P,[XWD 1,1]
EOLSE3:	MOVE AC3,VPOS(DAT)	; WE ARE NOW ON THE NEXT LINE. BUMP VERTICAL POSITION COUNTER.
	ADDI AC3,1		; DON'T BUMP IN CORE UNTIL WE HAVE POINTER PLANTED
	CAMLE AC3,GLW(DAT)	; IS THIS FURTHER DOWN THAN THE PRESENT MAXIMUM LINE WRITTEN?
	MOVEM AC3,GLW(DAT)	; YES, BUMP NUMBER OF MAXIMUM LINE WRITTEN
	PUSHJ P,GLNADR		; PICK UP POINTER INTO LINE TABLE
	MOVE AC2,PPTR1(DAT)	; NOW PICK UP THE POINTER
	MOVEM AC2,@PTRB(DAT)	; PUT IT INTO LINE POINTER TABLE INDEXED BY LINE NUMBER
	AOS VPOS(DAT)		; NOW UPDATE VERTICAL POSITION
	MOVEI CHR,12		; FAKE UP SOMETHING FOR ERRP (AGGG!)
	POPJ P,
;GLNADR GLNAD1 GLNAD2 GLNAD3 GLNAD4 GLNAD6

; HANDY ROUTINE TO GET POINTER TO TEXT FROM LINE NUMBER IN AC3
; RETURNS POINTER IN AC2.

GLNADR:	ADD AC3,PTBEG(DAT)	; ADD IN INCREMENT
GLNAD2:	CAMGE AC3,[-=20]	; UNDERFLOW?
	JRST GLNAD1		; YES, BOOST IT
GLNAD4:	CAIL AC3,=60		; OVERFLOW?
	JRST GLNAD3		; YES, BRING IT BACK INTO RANGE
	HRRZ AC2,PTRB(DAT)	; PICK UP POINTER
	SUBI AC2,=20
	CAME AC2,PTB(DAT)	; IS IT WHAT IT IS SUPPOSED TO BE?
	JRST GLNAD5		; NO, ERROR
GLNAD6:	HRRZ AC2,@PTRB(DAT)	; PICK UP POINTER
	POPJ P,

GLNAD1:	ADDI AC3,=80
	JRST GLNAD2

GLNAD3:	SUBI AC3,=80
	JRST GLNAD4
;GLNAD5 GLNAD7 HELPX

; WE GET HERE IF THE POINTERS DON'T AGREE

GLNAD5:	PUSHACS
	PUSH	P,PTRB(DAT)
	PUSHJ	P,DISMES
	ASCIZ 	/PTRB CLOBBERED TO /
	POP	P,TAC
	PUSHJ	P,DISOCT
	PUSHJ	P,DISCRLF
	POPACS
	HRRZ AC2,PTB(DAT)	; PICK UP THE (HOPEFULLY) CORRECT POINTER
	CAML AC2,MEMSIZ
	CAML AC2,RMEMSIZ
	JRST GLNAD7
	ADDI AC2,=20
	HRLI AC2,AC3		; SET TO INDEX BY AC3
	MOVEM AC2,PTRB(DAT)
	JRST GLNAD6

GLNAD7:	HRRZ AC2,PTRB(DAT)
	SUBI AC2,=20
	CAML AC2,MEMSIZ
	CAML AC2,RMEMSIZ
	JRST HELPX
	HRRZM AC2,PTB(DAT)
	JRST GLNAD6

HELPX:	PUSHJ	P,DISMES
	ASCIZ 	/CAN'T FIX IT
/
	PUSHJ	P,DISFLUSH
	PUSHJ	P,WDDTCALL
	HALT	AUTOLOAD
;POSLIN POSLDM POSLDD POSLII NODMDP

; ROUTINE TO CONVERT THE POSITION VECTOR INTO A DATA DISC,
; III, OR DATAMEDIA LINE NUMBER FROM 1 TO N, DEPENDING ON DISPLAY.

POSLIN:	LDB AC3,[POINT 11,PPOSV(DAT),21]
	TRNE AC3,1⊗=10		; EXTEND SIGN BIT
	OR AC3,[-1⊗=10]		; BY ORING IN BITS
	JRST @PPDPY(DAT)	; GO TO SELECTED ROUTINE

NODMDP:	PUSHACS
	PUSHJ P,DISMES		;HORRIBLE ERROR
	ASCIZ /
DM: Unimplemented feature attempted--caller's address at -20(P).
/
	PUSHJ P,WDDTCA
	POPACS
	JRST 4,AUTOLOAD

POSLDD:	IMULI AC3,=20		; DD
	ASH AC3,-=9		; THIS GIVES A NUMBER FROM -=19 TO =20
	MOVNS AC3		; FOR DD, ASCENDING LINE NUMBERS GO DOWN THE SCREEN
	ADDI AC3,=20		; WE NOW HAVE A NUMBER FROM 1 TO =40 IN AC3
	POPJ P,

POSLDM:				; DM ALSO HAS 24 LINES ON SCREEN
POSLII:	IMULI AC3,=12		; III ONLY HAS 24 LINES ON THE SCREEN
	ASH AC3,-=9
	MOVNS AC3
	ADDI AC3,=12
	POPJ P,
;FBLK FB1 PR1FRE PR1ER2 PR1ER3 PR1ERR PR1ER1

FBLK:	PUSH P,AC1		;FREE SOME BLOCKS FROM P.P.
FB1:	MOVE AC1,GLCNT(DAT)
	SKIPLE BLKTOT(DDB)	;DID WE FREE ENOUGH BLOCKS ?
	CAIG AC1,1		;LESS THAN 1 GLITCH ON SCREEN ?
	JRST POPAJ		;YES. RESTORE AC1 AND RETURN.
	PUSHJ P,GLITCH		;MOVE PAPER ONE GLITCH.
IFE FTDM,<
	JRST FB1
>;¬FTDM
IFN FTDM,<
	TLNE DAT,DMLIN		;If DM, then GLITCH may not have freed a block
	SKIPG BLKTOT(DDB)
	JRST FB1
	PUSHACS
	PUSH P,BLKTOT(DDB)	;Number of extra blocks used
	HRRZ TAC1,PRGNUM(DDB)	;Line number
	PUSH P,TAC1
	PUSHJ P,DISERR
	[ASCIZ /DM LINE ON TTY/]
	DISARG OCT,<-1(P)>
	[ASCIZ / USING /]
	DISARG DEC,<-2(P)>
	[ASCIZ / EXTRA PP TEXT BLOCK(S).
/]
	-1
	SUB P,[2,,2]
	POPACS
	JRST POPAJ
>;FTDM

PR1FRE: MOVE AC2,TBLKPT(DAT)	;WE HAVE FINISHED WITH ANOTHER BLOCK. GET PTR. TO IT.
	MOVEI AC1,TBLKBT	;CODE BIT FOR GC MEANING `TOP BLK OF PAGE'
	ANDCAM AC1,BLKBTS(AC2)	;TURN IT OFF IN OLD TOP BLK.
	HRRZ AC2,LINK(AC2)	;GET FORWARD PTR. (TO NEW TOP BLK.)
	CAML AC2,MEMSIZ
	CAML AC2,RMEMSIZ
	JRST PR1ERR		; GROSS ERROR!
PR1ER2:	MOVEM AC2,TBLKPT(DAT)
	IORM AC1,BLKBTS(AC2)
	SOSG OUTCNT(DAT)	;HAVE WE ENOUGH UNUSED BLOCKS FOR A DISK OUTPUT ?
	PUSHJ P,PPOUT		;YES. GET RID OF THEM.
	POPJ P,

PR1ER3:	PUSHACS
	PUSHJ	P,DISMES
	ASCIZ	/FIND A WIZARD OR RELOAD
/
	PUSHJ	P,DISFLU
	PUSHJ	P,DDTCALL
	POPACS
	HALT	AUTOLOAD

PR1ERR:	HRRZ	AC3,PRGNUM(DDB)
	PUSHACS
	PUSH	P,AC3
	PUSH	P,AC2
	PUSHJ	P,DISMES
	ASCIZ	/BAD POINTER AT PR1FRE: /
	POP	P,TAC
	PUSHJ	P,DISLOC
	PUSHJ	P,DISMES
	ASCIZ	/,  TTY = /
	POP	P,TAC
	PUSHJ	P,DISLOC
	PUSHJ	P,DISCRLF
	POPACS
	MOVEI	AC1,=20*=40/INITWC
	MOVE	AC3,CBLKPT(DAT)
PR1ER1:	MOVEI	AC2,(AC3)
	HLRZ	AC3,LINK(AC3)
	CAML	AC3,MEMSIZ
	CAML	AC3,RMEMSIZ
	JRST	PR1ER3
	CAME	AC3,TBLKPT(DAT)
	SOJG	AC1,PR1ER1
	JUMPLE	AC1,PR1ER3
	MOVE	AC3,TBLKPT(DAT)
	HRLM	AC2,LINK(AC3)
	MOVEI	AC1,TBLKBT
	JRST	PR1ER2
;PPOUT SETRST PPRST

PPOUT:  ;WE GET HERE WHEN IT IS TIME TO OUTPUT PART OF A PIECE OF PAPER TO THE DISK.
	MOVEI AC3,OUTNUM	;NO. OF BLOCKS TO PUT OUT.
	MOVEM AC3,OUTCNT(DAT)	;RESET IT.
	MOVE AC1,FBLKPT(DAT)	;POINTER TO FIRST BLK IN CORE.
	SKIPA AC2,AC1
	HRRZ AC2,LINK(AC2)	;GO TO NEXT BLOCK.
	SOJG AC3,.-1		;GO TO LAST BLOCK TO BE OUTPUT.
;;SINCE CROCKISH R. SAUNDERS HAS NO DISK CODE YET, WE JUST RETURN THE BLOCKS TO FREE STORAGE.
	HRRZ AC3,LINK(AC2)	;NEXT BLK.
	HRRZM AC3,FBLKPT(DAT)	;MAKE FBLKPT POINT TO NEW FIRST BLOCK IN CORE.
	HRLM DAT,LINK(AC3)	;MAINTAIN REV LINK
	SETZM LINK(AC2)		;ZERO LINK IN LAST BLOCK TO BE FREED.
↑SETRST:PUSHJ P,FREEL		;FREE THE BLOCKS.
	SKIPN III(DDB)		;IS IT AN III?
	POPJ P,			;NO.
PPRST:	HRRZ AC3,PRGNUM(DDB)	;GET TTY NUMBER
	MOVEI AC2,PSELB(DDB)	;YES. INVENT A RESTARTING JMP FOR IT AND
	HRLI AC2,DISJMP		; PLACE IN RSTTBL SO PRGM WILL GET STARTED AT
	MOVSM AC2,RSTTBL-DPYL0(AC3)	;AT ITS BEGINNING NEXT TIME.
	POPJ P,
;ERRP2 ERRP3

;A SIMPLE MESSAGE PRINTER. JSA J,ERRP WITH
;BYTE PTR. TO TEXT FOLOWING THE JSA .

↑ERRP2:	HLRZ	DAT,PPCALL(DDB)	;GET P OF P 0.
	HLL	DAT,DDB		;COPY OVER THE DISPLAY-TYPE BIT
	PUSHACS			;SAVE ALL OUR ARGUMENTS
	MOVE	J,JOB(PID)
	PUSHJ	P,PPCLR		;RESET THE PAGE PRINTER
	MOVE	J,-17+J(P)
	MOVE	TAC,(J)		;GET BYTE POINTER TO MESSAGE.
ERRP3:	OFFSCN			;TURN OFF SCANNER CHANNEL
	ILDB	CHR,TAC		;GET NEXT CHRARACTER
	PUSHJ	P,DTYO		;TYPE A CHAR.
	ONSCN			;TURN ON SCANNER CHANNEL
	JUMPN	CHR,ERRP3	;LOOP UNTIL FIRST NULL CHAR.
	POPACS
	JRA	J,1(J)
;PPFND1 PFL2 PPFND PPFER

;;HERE ARE UUO LEVEL ROUTINES FOR MANIPULATING THE PAGE PRINTER.

;;THESE ROUTINES ARE ENTERED WITH STANDARD UUO LEVEL
;; SETUP OF AC'S UUO AND J, WITH
;; DDB (≡DEVDAT) POINTING TO DPY PROGRAM HEADER.


;;PPFIND FINDS PIECE OF PAPER INDICATED BY (UUO); CREATES IT IF NECESSARY.
;; RETURNS WITH DAT POINTING TO P. OF P. CONTROL BLOCK.

PPFND1:	HLL DAT,DDB		;PICK UP DISPLAY-TYPE BIT
	HLRZ AC2,PPCALL(DDB)	;GET PTR. TO FIRST P. OF P.
	HRRZ TAC,UUO		;NO. OF PIECE WE ARE LOOKING FOR.
	CAIL TAC,20		;BETTER NOT BE TOO HIGH.
	JRST PPFER		;LOSE, LOSE.
PFL2:	HRRM AC2,DAT		;LOOK AT NEXT P. OF PAPER.
	CAMN TAC,PPNO(DAT)	;IS IT THE ONE WE WANT ?
	POPJ P,			;YES.
	HRRZ AC2,LINK(DAT)	;GET LINK TO NEXT ONE.
	JUMPN AC2,PFL2		;LOOP IF THERE IS A NEXT ONE.
	POPJ P,

PPFND:	PUSHJ P,PPFND1		;FIND INDICATED P OF P.
	JUMPN AC2,CPOPJ		;RETURN IF IT EXISTS.
	PUSH P,DAT		; SAVE POINTER TO LAST PROGRAM HEADER
	PUSH P,TAC		; SAVE NUMBER OF DESIRED PIECE OF PAPER
	HLRE TAC,PRGNUM(DDB)	; PICK UP DD CHANNEL OR DISPLAY-TYPE BIT FOR PPINIT
	PUSHJ P,PPINIT		; MAKE A NEW PIECE APPEAR.
	JSP UUO,DWPERR		; NOT THERE, GHASTLY ERROR
	POP P,PPNO(AC1)		;MAKE IT HAVE RIGHT NO.
	POP P,DAT		; GET BACK POINTER TO LAST PIECE OF PAPER
	HRRM AC1,LINK(DAT)	;LINK IT TO OTHER PIECES.
	HRLZM DAT,LINK(AC1)	;PUT IN ITS BACKWARD LINK.
	HRRZM DDB,HEDPTR(AC1)	;GIVE IT PTR. TO PRGM. HEAD.
	MOVE AC3,PPRJMP(DAT)	;GET LINKING (I. E. RETURN) JMP FROM LAST P OF P...
	MOVEM AC3,PPRJMP(AC1)	;GIVE IT TO NEW PIECE...
	HRLM AC1,PPRJMP(DAT)	;.. AND MAKE LAST PIECE CALL NEW ONE.
	MOVEM AC1,DAT
	HLL DAT,DDB		; PUT IN TYPE BITS
	POPJ P,

PPFER:	;PRINT H. S. MESSAGE.
	ERMS {ILLEGAL PIECE OF PAPER}
	JRST UUOERR		;NOW GIVE STANDARD JUNK AND STOP JOB.
;PPSEL1 PPREL PPREL2 PPREL3 PPREL4 PPSEL0 CLKREL

;;MORE PP ROUTINES.

PPSEL1: PUSHJ P,PPFND		;LOCATE P. OF P. INDICATED BY UUO.
	HRRZM DAT,CURPP(DDB)	;MAKE IT THE CURRENT ONE.
	MOVEI UUO,400000	;PREPARE TO ACTIVATE IT,
	MOVN TAC,PPNO(DAT)	; BY GENERATING PARAM. FOR
	LSH UUO,(TAC)		; CALL ON PPACT.
	POPJ P,

PPREL:	TRNN UUO,-1		;FLUSH PP WHOSE NUMBER IS IN UUO (RIGHT)
	POPJ P,			;BUT NOT IF IT'S PP ZERO
	PUSHJ P,PPFND1		;FIND P OF P
	JUMPE AC2,CPOPJ		;SAVE SOME TIME IF THERE IS NONE
	PUSH P,DDB
	PUSHJ P,PPWAIT		;WAIT FOR ANY TYPEOUT TO FINISH BEFORE FLUSHING PAGE
	POP P,DDB
	PUSHJ P,PPFND1		;NOW SEE IF P OF P IS STILL THERE
	JUMPE AC2,CPOPJ		;RETURN IF NOT.
	MOVE AC1,LINK(DAT)	;SIGH.  GET FWD AND BWD LINKS FROM CTRL. BLK.
	TRNE AC1,-1		;UNLESS CTRL. BLK IS LAST ONE,
	HLLM AC1,LINK(AC1)	;..UPDATE BWD LINK OF NEXT ONE.
	MOVSS AC1
	HLRM AC1,LINK(AC1)	;NOW FWD LINK OF PREVIOUS ONE (AREN'T LINKED LISTS FUN ?)
	MOVE AC3,PPRJMP(DAT)	;TAKE LINKING JMP FROM THIS BLK...
	MOVEM AC3,PPRJMP(AC1)	;..AND GIVE IT TO PREVIOUS ONE.
	JUMPL DAT,PPREL3	; DON'T ERASE IF III, WILL BE DONE AUTOMATICALLY
	PUSHJ P,POSLIN		; GET FIRST LINE NUMBER OF PAGE
	PUSH P,AC3
	PUSH P,GLW(DAT)		; ERASE ALL THE WAY TO THE LAST LINE
	SOS (P)
	PUSHJ P,PPERS
	SUB P,[XWD 2,2]		; NORMALIZE THE STACK
PPREL3:	MOVEM	DDB,LINK(DAT)	;SINCE WE ARE LINKED OUT, WE CAN USE THIS TO
				;SAVE DDB IN CASE OF A CLOCK CALL LATER
PPREL4:	MOVE	DDB,LINK(DAT)	;MAKE SURE DDB IS SET UP
	SKIPN	PPENQ(DAT)	;ANYTHING HAPPENING HERE?
	SKIPE	PPNQT(DAT)
	JRST	CLKREL		;YES, DON'T RELEASE IT UNTIL IT IS DONE
	MOVE	AC1,DAT		;NOW FREE THE CTRL BLK.
	PUSHJ	P,CGIVFS
	MOVE	AC1,FBLKPT(DAT)	;ALSO FREE THE PROGRAM BLOCKS.
	PUSHJ	P,FREEL
	HRRZ	AC1,PTB(DAT)	;GIVE BACK TABLE OF END OF LINE POINTERS
	PUSHJ	P,FSGIVE
PPREL2:	HRRZ	AC1,DAT
	CAME	AC1,CURPP(DDB)	;HAVE WE JUST DELETED SELECTED P OF P ?
	POPJ	P,		;NO
PPSEL0:	MOVEI	UUO,0		;YES. SELECT PP 0.
	JRST	PPSELN

CLKREL:	HRLI	DAT,PPREL4
	JRST	DPYTIM
;PPSEL PPSELN PPACT0 PPACT PACTL1 PACTL2 PACTL3 PACTL4

;;PPSEL <N>  MAKES P. OF P. <N> THE CURRENT ONE AND TURNS IT ON.

PPSEL:	PUSHJ P,PPWAIT		; WAIT FOR TYPEOUT TO FINISH
	PUSHJ P,PRGFND
	POPJ P,			; NO DPY HERE, JUST IGNORE
PPSELN:	MOVEI AC1,PPACT		;ASSUME WE WANT TO CALL PPACT
	TRZE UUO,400000		;THIS BIT ON IN PP NUMBER MEANS DON'T CALL PPACT
	MOVEI AC1,PPACT0	;NO CHANGE TO ACTIVATED PP'S THIS TIME
	PUSH P,AC1		;ADDRESS OF ROUTINE TO RETURN TO
	JRST PPSEL1		;FIND IT, SELECT IT, AND RETURN OR CALL PPACT.

;;PPACT X TURNS P OF P'S ON AND OFF ACCORDING TO BITS IN X;
;;  BIT N+18 CORRESPONDS TO P. OF P. N.

;GET TO PPACT0 TO INSURE THAT NEW PP'S, WHICH ARE NOT ACTIVATED, HAVE CORRECT
;VALUE IN TPJMP.  GET THERE FROM PPSEL 400000+PP# WHERE PP# IS NEW.
PPACT0:	MOVE UUO,PRGACT(DDB)	;USE OLD PP ACTIVATION BITS
PPACT:	MOVEI AC1,DISJMP	;JMP OPCODE FOR DPY.
	MOVEI AC2,DISNOP
	HLRZ AC3,PPCALL(DDB)	;GET FIRST P OF P.
PACTL1:	MOVE TAC,UUO		;MAKE COPY OF THE X BITS.
	ROT TAC,@PPNO(AC3)	;GET BIT FOR THIS P OF P INTO 18.
	HRRM AC2,TPJMP(AC3)	;ASSUME BIT IS OFF.
	TRNE TAC,400000		;IS IT ?
	HRRM AC1,TPJMP(AC3)	;NO. ACTIVATE THE P OF P.
	MOVE TAC1,PRGACT(DDB)	; PICK UP CURRENT ACTIVATION BITS
	ROT TAC1,@PPNO(AC3)	; PUT BIT FOR THIS PP IN B18
	XOR TAC1,TAC		; ARE THEY DIFFERENT?
	TRNE TAC1,400000
	JRST PACTL2		; YES, MARK AS VIRGIN IF APPEARING, ELSE ERASE
PACTL3:	HRRZ AC3,LINK(AC3)	;GET NEXT P OF P HEADER.
	JUMPN AC3,PACTL1	;LOOP IF THERE IS ONE.
	HRRM UUO,PRGACT(DDB)	;ALL DONE. RECORD NEW STATE OF ACTIVATION.
	POPJ P,

PACTL2:	TRNN TAC,400000		; NOW, ARE WE APPEARING OR DISAPPEARING?
	JRST PACTL4		; DISAPPEARING, GO ERASE SCREEN
	SETOM PPVIRG(AC3)	; APPEARING, NOTE A VIRGIN SCREEN
	JRST PACTL3

PACTL4:	SKIPE PPVIRG(AC3)	; IS THERE ANYTHING THERE?
	JRST PACTL3		; NO, NOTHING TO ERASE (III ALWAYS GETS OUT HERE)
	PUSH P,DAT		; SAVE PAGE PRINTER CONTROL BLOCK ADDRESS
	MOVE DAT,AC3		; MAKE US THE ONE
	PUSHJ P,POSLIN		; GET BOUNDS OF PAGE IN LINE NUMBERS
	PUSH P,AC3		; THAT IS FIRST LINE
	PUSH P,GLW(DAT)		; CURRENT LINE IS LAST LINE
	SOS (P)
	PUSHJ P,PPERS		; CAUSE ERASURE TO HAPPEN
	SUB P,[XWD 2,2]
	MOVE AC3,DAT		; PUT PAGE PRINTER CONTROL BLOCK ADDRESS BACK
	POP P,DAT
	MOVEI AC1,DISJMP
	MOVEI AC2,DISNOP
	JRST PACTL3
;PPWAIT PPWAT2 PPWAT3 PPWAT4

; ROUTINE TO WAIT FOR TYPEOUT TO FINISH

↑PPWAIT:
	CONSZ PI,77400		; CAN'T DO THIS AT INTERRUPT LEVEL
	POPJ P,
	MOVE J,JOB(PID)
	MOVE DDB,JBTLIN(J)	;FIND GUY'S TTY.
	CAME DDB,[-1]		; IS HE DETATCHED?
	SKIPN DDB,TTYTAB(DDB)	; GET TTY DDB, DOES HE EXIST?
	POPJ P,			; HMM. WELL, BE THAT WAY!
	SKIPN JBTPAG(J)		;IN CASE OF KJOB (I.E., NO CORE), WE CAN'T WAIT
	POPJ P,
PPWAT4:	MOVEI TAC,TTOCHR	;MAKE SURE OUTPUT BUFFER IS EMPTY
	CAMG TAC,TTOBUF+FCTR(DDB)
	JRST PPWAT3
;	MOVE TAC,DEVIOS(DDB)
;	TLNE TAC,TOIP		;SKIP IF NO OUTPUT IS IN PROGRESS
	PUSHJ P,DDTWAT		;WAIT FOR THE TYPEOUT TO TERMINATE
	JRST PPWAT4		;CHECK AGAIN BECAUSE WE CAN BE AWAKENED PREMATURELY

PPWAT3:	MOVE J,JOB(PID)		;J MAY BE CLOBBERED BY DDTWAT
PPWAT2:	LDB TAC,PUNIT		;GET LINE NUMBER
	SKIPE TAC,LETAB(TAC) 	;GET DPY HEADER
	SKIPG NPPXFR(TAC)	;ANY PP TRANSFERS G∪ING?
	POPJ P,			;NO
	PUSHJ P,WSCHED		;YES, WAIT A BIT
	JRST PPWAT2		;AND THEN CHECK AGAIN
;PPYPOS PPYPO1 PPYPO3 PPYPO4 REFPAG

;;PPYPOS Y MAKES THE CURRENT P OF P START AT Y COORD. Y.
PPYPOS: SETZ AC1,
	DPB AC1,POSSBU		; NOTE Y-POSITION SET BY UUO
	PUSHJ P,POSLIN		; GET LINE NUMBER OF CURRENT LINE
	PUSH P,AC3		; AND PUSH IT
	PUSH P,GLW(DAT)		; SAVE BOTTOM OF PAGE
PPYPO1:	SETOM PPINV(DAT)	; NOTE POINTERS ARE BEING CHANGED
	DPB UUO,[POINT 11,PPOSV(DAT),21] ;PUT NEW Y COORD. INTO POSITION VECTOR
	PUSHJ P,POSLIN		; NOW PICK UP NEW 1ST LINE OF PAGE
	MOVE AC1,AC3
	MOVE AC2,AC3
	MOVN AC3,-1(P)
	ADD AC3,AC1		; UPDATE VERTICAL POSITION
	JUMPE AC3,PPYPO3	; IF NO DIFFERENCE, WE DON'T HAVE TO MOVE LINE POINTER TABLE
	MOVEM AC2,LLW(DAT)	; MAKE SURE WE START AT THE LOGICAL TOP OF PAGE
	PUSHJ P,PTMOVE		; MOVE POINTERS
	ADDM AC3,VPOS(DAT)
	SETZM PPINV(DAT)	; NOTE POINTERS ARE VALID NOW
	JUMPL DAT,PPYPO3	; IF III, LEAVE NOW
	JUMPN AC3,PPYPO2	; IF WE ARE MOVING DOWN, WE HAVE TO ERASE EXPLICITLY
PPYPO4:	SUB P,[XWD 2,2]		; OTHERWISE, WE CAN PRETEND WE ARE GLITCHING
REFPAG:	JUMPL DAT,CPOPJ		; LEAVE IF III
	PUSH P,DAT		; SAVE THE POINTER TO THE PAGE PRINTER CONTROL BLOCK
	HRRZ DAT,HEDPTR(DAT)	; PUT DPY PROGRAM HEADER ADDRESS IN DAT
	PUSHJ P,LERFP		; GET IT DONE AUTOMATICALLY.
	POP P,DAT		; GET BACK OUR PAGE PRINTER CONTROL BLOCK ADDRESS
	POPJ P,

PPYPO3:	SUB P,[XWD 2,2]		; RESTORE THE STACK
	SETZM PPINV(DAT)	; POINTERS ARE OK NOW
	POPJ P,
;PPYPO2 PPYPO5 PPYPDN PPYPDM

; WE GET HERE WHEN THE APPEARANCE OF THE PAGE HAS CHANGED ENOUGH
; SO THAT THE PAGE HAS TO BE REFRESHED.

PPYPO2:	ADDM AC3,GLW(DAT)	; UPDATE THE NUMBER OF THE LAST LINE WRITTEN
	HRRZ AC1,TPJMP(DAT)	; PICK UP JUMP TO TEXT
	SKIPN PPVIRG(DAT)	; DON'T ERASE A VIRGIN SCREEN!
	CAIN AC1,DISNOP		; IS IT REALLY A JUMP?
	JRST PPYPO4		; NO, DON'T WRITE ON IT
	MOVE AC2,(P)		; PICK UP FINISHING LINE OF TRANSFER
	SUB AC2,-1(P)		; GET LENGTH OF PAGE MINUS 1
	MOVM AC1,AC3		; GET MAGNITUDE OF TRAVEL
	CAML AC1,AC2
	JRST PPYPO5		; IF TRAVEL LARGER THAN PAGE, ERASE ENTIRE PAGE
IFN FTDM,<
	TLNE DDB,DMLIN		;If any overlap on DM, just slide PP to new position
	JRST PPYPDM		; by using ADD-ROW or DELETE-ROW chars
>;FTDM
	SUB AC2,AC1		; OTHERWISE, ERASE ONLY NON-OVERLAPPED PART
	MOVN AC1,AC2
	SKIPG AC3		; IF GOING UP,
	JRST PPYPDN		; THEN ERASE FROM THE MIDDLE DOWN TO THE BOTTOM
	ADDM AC1,(P)
	SOS (P)
PPYPO5:	PUSHJ P,PPERS
	JRST PPYPO4

PPYPDN:	ADDM AC2,-1(P)
	JRST PPYPO5

IFN FTDM,<
PPYPDM:	SUB P,[2,,2]		;Flush data
	EXCH DAT,UUO		;Put PP pointer into UUO for next routine
	PUSHJ P,DMSHFT		;Move text up or down with glitching routine
	EXCH DAT,UUO
	POPJ P,
>;FTDM
;PPERS DMERS

; ROUTINE TO ERASE PARTS OF DATA DISK SCREEN or Datamedia screen
; CALL WITH STARTING LINE OF ERASURE AT -2(P)
; ENDING LINE AT -1(P)

PPERS:	PUSHJ P,GETQ		; GET A TASK BLOCK (DM needs one, DD needs two)
IFN FTDM,<
	TLNE DDB,DMLIN
	JRST DMERS		; Different routine for DM
>;FTDM
	PUSH P,AC1		; SAVE ITS ADDRESS
	PUSHJ P,GETQ		; GET ANOTHER ONE
	POP P,TAC		; GET BACK THE ADDRESS OF THE FIRST ONE
	MOVE AC2,-2(P)		; PICK UP STARTING LINE OF TRANSFER
	MOVE AC3,-1(P)		; AND ENDING LINE OF TRANSFER
	CAMGE AC3,AC2		; IF THE FINISHING LINE IS ABOVE THE STARTING LINE . . .
	MOVE AC3,AC2		; THEN ONLY ERASE ONE LINE
	HRLM AC2,QLINE(AC1)	; MAKE THIS THE STARTING LINE NUMBER OF THE ERASURE
	HRLM AC2,QLINE(TAC)
	HRRM AC3,QLINE(AC1)
	HRRM AC3,QLINE(TAC)
	HRLM DAT,(AC1)		; PUT IN PAGE PRINTER CONTROL BLOCK ADDRESS
	HRLM DAT,(TAC)
	MOVEI AC2,ERASE		; CALL THE ERASE CODE
	HRRM AC2,(AC1)
	HRRM AC2,(TAC)
	SETZM QFIELD(TAC)	; MAKE THE FIRST TASK GO OUT ON THE FIRST FIELD
	SETOM QFIELD(AC1)	; AND THE SECOND TASK GO OUT ON THE SECOND FIELD
	SETZM QCOUNT(TAC)	; NOTE THAT WE DON'T CARE TO BE AWAKENED
	SETZM QCOUNT(AC1)
	PUSH P,TAC		; SAVE THE ADDRESS OF ONE OF THE BLOCKS
	PUSHJ P,QBLOCK		; QUEUE THE BLOCK
	POP P,AC1		; GET BACK THE ADDRESS OF THE OTHER
	JRST QBLOCK		; QUEUE IT UP TOO

IFN FTDM,<
;Routine to erase lines on DM screen
DMERS:	MOVEI AC3,CHASTE	;Make it erase each line encountered
	HRL AC3,DDB
	MOVEM AC3,QFLAGS(AC1)
	SOS AC3,-2(P)		;First line to be erased, normalized for DM
	MOVEM AC3,QXY(AC1)
	MOVE TAC,-1(P)		;Ending line number
	SUB TAC,AC3		;Number of lines to erase
	JUMPG TAC,.+2
	MOVEI TAC,1		;Ending line above beginning, so erase just one line
	MOVEM TAC,QDMCNT(AC1)
	MOVE AC3,[440700,,DMLFS];Put out that many LFs
	MOVEM AC3,QTAKR(AC1)
	SETZM QCOUNT(AC1)
	MOVEI AC2,DMPPPT-QLINK(DDB)
	JRST QDM
>;FTDM
;PTMOVE PTMOV1 PTMOV2 PTMOV3 PTMOV4

; HERE IS A ROUTINE TO MOVE THE LINE POINTER TABLE AROUND
; IN A CIRCULAR FASHION, SO AS NOT TO LOSE ANY POINTERS.
; CALL WITH NUMBER OF LINES TO BE MOVED IN AC3. NEGATIVE
; MEANS SCREEN IS MOVING UP, POSITIVE MEANS IT IS MOVING DOWN.
; NUMBER IS ASSUMED TO BE -=79 TO =79

PTMOVE:	PUSH P,AC3		; SAVE COUNT
	MOVNS AC3
	ADD AC3,PTBEG(DAT)	; ADD IN TO CURRENT INCREMENT
PTMOV2:	CAIL AC3,=80		; IS THE INCREMENT OUT OF RANGE?
	JRST PTMOV1		; YES, BRING IT BACK IN
PTMOV4:	SKIPGE AC3		; SAME FOR NEGATIVE
	JRST PTMOV3
	MOVEM AC3,PTBEG(DAT)
	POP P,AC3
	POPJ P,

PTMOV1:	SUBI AC3,=80
	JRST PTMOV2

PTMOV3:	ADDI AC3,=80
	JRST PTMOV4
;PPXSIZ PPX1 PPX2 PPXERR

;;PPXSIZ <N>B26 ! <M>  SETS CURRENT P OF P TO HAVE N GLITCHES OF M LINES.

PPXSIZ: SETZ AC1,
	DPB AC1,SIZSBU		; NOTE THAT PAGE SIZE SET BY UUO
	MOVE AC1,GLCNT(DAT)	; PICK UP NUMBER OF GLITCHES SO FAR ON THIS PAGE
	IMUL AC1,DEL(DAT)	; MULTIPLY BY NUMBER OF LINES IN PER GLITCH
	SUB AC1,DELCNT(DAT)	; ADD IN NUMBER OF LINES SO FAR IN LAST GLITCH
	PUSH P,AC1		; AND SAVE THIS
	LDB AC1,[POINT 9,UUO,26];NO. OF GLITCHES REQUESTED.
	LDB AC2,[POINT 9,UUO,35];NO. OF LINES/GLITCH.
IFN FTDM,<
	CAMN AC1,PGSIZ(DAT)	;Is number of glitches changing?
	CAME AC2,DEL(DAT)	;Or size of each glitch?
	JRST .+2		;Yes
	JRST POPAJ		;No change, POP AC1 and return
>;FTDM
	IMUL AC2,AC1		;TOTAL SIZE OF REQUESTED PAGE, IN LINES.
	CAIG AC2,1		; MUST END UP 2 OR MORE LINES LONG
	JRST PPX1
	MOVEI AC3,=40		; DATA DISK TAKES 40 LINES
	CAIG AC2,(AC3)		;MORE THAN 40 LINES ?
	CAILE AC1,CNT		;TOO MANY GLITCHES ?
	JRST PPXERR		;YES. LOSE.
PPX2:	MOVEM AC1,PGSIZ(DAT)	;UPDATE GLITCHES/PAGE.
	DPB UUO,[POINT 9,DEL(DAT),35]	;UPDATE GLITCH SIZE.
	POP P,AC1		; GET NUMBER OF LINES ON PAGE
	IDIV AC1,DEL(DAT)	; SEE HOW MANY NEW GLITCHES THAT MAKES
	SUB AC2,DEL(DAT)	; MAKE INTO NUMBER OF LINES TO GO
	MOVNM AC2,DELCNT(DAT)	; SET NUMBER OF LINES TO GO IN CURRENT GLITCH
	ADDI AC1,1		; Make it go from 1 to PGSIZ
	MOVEM AC1,GLCNT(DAT)	; THIS IS OUR NEW GLITCH COUNT
	PUSHJ P,ADJSIZ		;.. AND GO ADJUST TO NEW SIZE by glitching if needed
IFE FTDM,<
	JRST REFPAG
>;¬FTDM
IFN FTDM,<
	TLNN DAT,DMLIN		;Don't redraw whole screen on DM	
	JRST REFPAG		; REFRESH NEW PAGE
	MOVE UUO,DAT		;Current PP pointer and display bit
	JRST LERDM2		;Now call QDMR to put out any new glitches needed
>;FTDM

PPXERR:	CONSZ PI,77400
	JRST POPAJ
	ERMS {ILLEGAL PAGE SIZE SPEC.}
	JRST UUOERR

PPX1:	MOVEI UUO,2		; GIVE HIM A MINIMUM SIZE PAGE
	MOVEI AC1,1
	JRST PPX2
;DPYCLK CLKL1 CLKRTN

;;CLKSER	;THIS IS DPYSER'S OWN PRIVATE CLOCK QUEUER.

↑DPYCLK:  ;HERE FROM CLKSER EVERY TICK.
	HGMAC(35)
	SKIPE AC1,FSWTHD	;ANYTHING IN THE FREE STG. WAIT LIST ?
	PUSHJ P,FREE		;YES. GO PUT IT ON FREE STG. LIST.
	CONO PI,PIOFF		;...PEOPLE MAY USE FSWT2H AT INT. LEVEL...
	MOVE AC1,FSWT2H		;MOVE THINGS UP FROM THE SECOND-LEVEL WAIT LIST.
	MOVEM AC1,FSWTHD
	SETZM FSWT2H
	CONO PI,PION
	MOVE AC1,FSW2C
	MOVEM AC1,FSWC
	SETZM FSW2C
	HGMAC(36)
	SKIPLE WHOPTR		; IF NEW WHO JUST UPDATED, SEND IT OUT NOW
	PUSHJ P,WHOQUE		; YES, QUEUE UP A REQUEST
IFN FTDM,<
	SKIPE AC3,WHDMPT	; Any new wholine request for DM?
	PUSHJ P,WHOQDM		; Yes, queue up a xfer
>;FTDM
	HGMAC(37)
	MOVEM P,BUGDPL		;*****SAVE FOR DPYPDL BUG TRAP
	EXCH P,DPYPDL		;YES. GET OUR OWN PDL.
	SETOM CLKLVL		;FLAG THAT WE ARE AT CLOCK LEVEL.
	AOSN WTFLG		;ARE WE IN A WAIT ?
	POPJ P,			;YES. RETURN TO THE WAITING ROUTINE.
	SKIPN @CLKQ		;ANY REQUESTS IN THE CLK QUEUE ?
	JRST CLKRTN		;NO. SEE HOW LITTLE TIME WE HAVE WASTED !!
	HRRZ TAC,CLKQ		;GET PTR. TO CURRENT END OF QUEUE.
	MOVEM TAC,CLKQTMP	;SAVE IT.
CLKL1:	CONO PI,PIOFF		;NO INTERRUPTS, PLEASE.
	MOVE DAT,@CLKQ		;GET LAST REQUEST FROM QUEUE.
	SOS CLKQ		;MOVE POINTER BACK BY 1.
	EXCH DAT,(TAC)		;PICK UP THE REQUEST WE ARE SERVICING..
	CONO PI,PION		;(DIDN'T SEE A THING, DID YOU ?)
	MOVEM DAT,SVDPDT	;*****SAVE DAT FOR BUG TRAP
	HLRZ TAC,DAT
	PUSHJ P,(TAC)		;..AND SERVICE IT, ALREADY.
	MOVE TAC,BUGDPL		;*****
	CAME TAC,DPYPDL		;*****
	JRST DPDLBG		;*****ROUTINE STEPPED ON DPYPDL
DPDLB1:	HGMAC(37)		;IN CASE SERVICE ROUTINE CHANGED HGCODE
	SOS TAC,CLKQTMP		;NOW GET PTR. TO NEXT LOWER ONE..
	CAIL TAC,CLKQUE		;ARE WE AT BOTTOM OF QUEUE ?
	JRST CLKL1		;NO. BACK FOR MORE.
CLKRTN: EXCH P,DPYPDL		;PUT BACK THE RIGHT PDL.
	SETZM CLKLVL		;NO LONGER IN CLOCK LEVEL CODE.
	POPJ P,

DPDLBG:	PUSHACS
	PUSHJ P,DISMES
	ASCIZ /DPYPDL CLOBBERED AT DPYCLK
/
	PUSHJ P,DISFLUSH
	POPACS
	PUSHJ P,WDDTCA
	MOVE TAC,BUGDPL		;WHO KNOWS WHAT CLOBBERAGE LURKS IN THE HEART
	MOVEM TAC,DPYPDL	;OF WDDTCA
	JRST DPDLB1
;WHOQUE WHOQ1 WHOQ2 WHOQDM

; THIS ROUTINE QUEUES UP ANOTHER DATA DISC WHO LINE REQUEST.
; ONLY ONE LINE IS QUEUED UP EVERY 12. TIX OR SO.
; CALLED FROM DPYCLK WHEN WHOPTR>0

WHOQUE:	MOVNI	AC3,2
	EXCH	AC3,WHOPTR	;PICK UP NUMBER OF WHO LINE JUST UPDATED
				;SET WHOPTR TO -2 TO AVOID RE-ENTERING HERE.
				;WHOWRT WILL AOS WHOPTR FOR EACH FIELD DONE.
				;WHOPTR=0 ALLOWS WHOSER TO MAKE A NEW WHO LINE
	MOVEI	DAT,0
	CAIN	AC3,DDAVLU	; AVLCHN FLAG
	JRST	WHOQ2
	SKIPE	DAT,FRETAB(AC3)	; PICK UP ADDRESS OF WHO DATA
	SKIPN	AC2,LETAB(AC3)	; PICK UP ADDRESS OF DPY PROGRAM HEADER
	JRST	WHOQ1		; LEAVE IF NONE THERE
	MOVE	AC2,CURPP(AC2)	; GET ADDRESS OF PAGE PRINTER CONTROL BLOCK
	MOVE	AC2,DDCW(AC2)	; PICK UP COMMAND WORD
;	SKIPN	DAT,FRETAB(AC3)	; PICK UP ADDRESS OF WHO LINE
;	JRST	WHOQ1		; LEAVE IF NONE THERE
	MOVEM	AC2,(DAT)	; PLACE IT IN THE WHO CODE
WHOQ2:	PUSHJ	P,GETQ
	MOVEM	AC3,QHPOS(AC1)	; SAVE THE DPY NUMBER HERE
	HRLI	DAT,WHOWRT
	MOVSM	DAT,(AC1)
	SETZM	QFIELD(AC1)	;ON FIELD ZERO
	MOVE	AC2,[XWD 1,2]	;ON TOP TWO LINES
	CAIN	AC3,DDAVLU
	MOVE	AC2,AVLLN
	MOVEM	AC2,QLINE(AC1)
	SETZM	QCOUNT(AC1)
	PUSH	P,AC3		;SAVE THE DPY NUMBER
	PUSHJ	P,QBLK		;QUEUE UP THIS FIELD'S WORTH.
	PUSHJ	P,GETQ
	POP	P,QHPOS(AC1)	;STORE THE DPY NUMBER
	MOVSM	DAT,(AC1)
	SETOM	QFIELD(AC1)	;FIELD 1
	MOVE	AC2,[XWD 1,2]
	CAIN	AC3,DDAVLU
	MOVE	AC2,AVLLN
	MOVEM	AC2,QLINE(AC1)
	SETZM	QCOUNT(AC1)
	JRST	QBLK

WHOQ1:	SETZM	WHOPTR		;HERE TO FLUSH THE WHO LINE REQUEST
	POPJ	P,		;WHOPTR MUST BE CLEARED.

IFN FTDM,<
;Here for DM wholine to be queued, with line number in AC3.
WHOQDM:	SKIPE	TEM,FRETAB(AC3)	; PICK UP ADDRESS OF WHO DATA
	SKIPN	DAT,LETAB(AC3)	; PICK UP ADDRESS OF DPY PROGRAM HEADER
	JRST	WHOQD1		; LEAVE IF NONE THERE
	HRLI	DAT,NOEEOL!TRUNCA ;Don't erase old lines and don't wrap around
;	LDB	AC3,[POINT 17,AC3,17] ;Get number of text words to suppress
;	SUBI	AC3,WLINK-WTEND	      ; minus number of text words there are
	JUMPGE	AC3,WHOQD2	;Jump if user line hasn't changed
	PUSHJ	P,GETQ		;Get a queue block for user line
	MOVSM	DAT,QFLAGS(AC1)
	MOVEI	TEM,WTEND(TEM)	;Address of text of user line
	HRLI	TEM,440700
	MOVEM	TEM,QTAKR(AC1)
	MOVEI	AC2,(WLINK-WTEND)*5 ;Length of user line in βhars
	MOVEM	AC2,QDMCNT(AC1)
	MOVEI	AC2,1
	MOVEM	AC2,QXY(AC1)	;Start at left margin on second line
	SETZM	QCOUNT(AC1)	;Don't wake anyone when done
	MOVEI	AC2,DMWHO-QLINK(DAT)
	PUSHJ	P,QDM		;Queue up the user line first
WHOQD2:	PUSHJ	P,GETQ		;Get a queue block for system line
	MOVSM	DAT,QFLAGS(AC1)
	MOVE	AC2,[440700,,COMWHO]
	MOVEM	AC2,QTAKR(AC1)
	MOVEI	AC2,LCOMDM*5-LCOMNL-2	;Length of system wholine in chars less CRLF
	MOVEM	AC2,QDMCNT(AC1)
	SETZM	QXY(AC1)	;Upper left corner
	SETZM	QCOUNT(AC1)	;Don't wake anyone over this xfer
	MOVEI	AC2,DMWHO-QLINK(DAT)
	PUSHJ	P,QDM		;And now queue the system line
	PUSHJ	P,STRTDM	;Start TTY
WHOQD1:	SETZM	WHDMPT
	POPJ	P,
>;FTDM
;FREE GETFS POPAJ CLKWAT ARRRGH

; ROUTINE TO FREE AN ENTIRE LIST OF BLOCKS, LINKED UP THROUGH LINK
; ENTER WITH TOP OF LIST IN TAC

FREE:	JUMPE AC1,CPOPJ
	CAML AC1,MEMSIZ
	CAML AC1,RMEMSIZ
	POPJ P,
	HRRZ TAC,LINK(AC1)	;GET LINK BEFORE GIVING BACK FREE STORAGE
	PUSHJ P,SFSGIV
	DPYFS
	MOVE AC1,TAC		;LOOP FOR NEXT BLOCK
	JRST FREE

GETFS:	PUSH P,AC1
	PUSHJ P,UGETFS		;GET A BLOCK OF FREE STG. (IN AC2).
	MOVE AC2,AC1
POPAJ:	POP P,AC1
	POPJ P,

CLKWAT:	CONSZ PI,77000
	JRST ARRRGH
	MOVEM 17,SVAC+17
	MOVEI 17,SVAC		;SAVE ALL AC'S.
	BLT 17,SVAC+16
	SETOM WTFLG		;SET WAIT FLAG FOR CLK SERVICE.
	PUSHJ P,CLKRTN		;GO AWAY FOR A TICK.
	MOVSI 17,SVAC		;RESTORE THEM.
	BLT 17,17
	POPJ P,

ARRRGH:	PUSHACS
	PUSHJ P,DISDAT
	PUSHJ P,DISMES
	ASCIZ /AT CLKWAT IN CH5!!!!!
/
	PUSHJ P,DISFLU
	SKIPN DEBMOD
	JRST AUTOLO
	POPACS
	PUSHJ P,DDTCAL
	JRST .-1	;BETTER NOT RETURN WITH POPJ
;PRGFND PRGF1 PRGF2 PRGF3 PRGFER PRGFE1 DDFND

;;UUO LEVEL UTILITY ROUTINES AND DISPATCHERS.

;;PRGFND  FINDS DPY PRGM FOR JOB IN J.

PRGF2:	MOVE DDB,PTYJOB-PTYL0(DDB)	;GET JOB WHICH OWNS PTY.
	SKIPA DDB,JBTLIN(DDB)		;USE HIS DPY, IF ANY.
PRGF1:	MOVE DDB,JBTLIN(J)		;GET `TTY' LINE NO. FOR JOB., IF ANY.
	TLNE DDB,PTYLIN			;IS GUY CONNECTED TO A PTY ?
	JUMPG DDB,PRGF2			;YES, UNLESS HE IS DETACHED.
	HRRZ AC1,DDB
	AOJE DDB,CPOPJ1			;IF DETACHED (=-1), GIVE ERROR RETURN
	TLNN DDB,DISLIN!DDDLIN!DMDLIN	; IS THIS A DPY OF SOME SORT?
	JRST CPOPJ1			; NO, ERROR
	HRRZ DDB,LETAB-1(DDB)		;GET PTR. TO PRGM HEADER.
PRGF3:	HLRZ AC1,PPCALL(DDB)		; GET POINTER TO PP 0
	HLL DDB,PPDPY(AC1)		; PICK UP DISPLAY-TYPE BIT
	POPJ P,

PRGFND:	SKIPN	DDB,DPYMAP(J)		;IS GUY CONNECTED TO SOMEONE ELSE'S DPY?
	PUSHJ	P,PRGF1			;NO. FIND ONE OF HIS OWN.
	JRST	CPOPJ1			;SUCCESS RETURN
PRGFER:	CONSO	PI,77400		;WHAT LEVEL ARE WE?
	POPJ	P,			;IF AT UUO LEVEL, ERROR RETURN
	PUSHJ	P,DISMES		;OTHERWISE, DISASTER
	ASCIZ	/ILLEGAL JOB NUMBER AT PRGFND NOT AT UUO LEVEL
/
	JRST	DPYATL

DDFND:	PUSHJ P,PRGFND		; USE PRGFND
	CAIA
	JRST CPOPJ1
	CAIE UCHN,3		; DDFND CALLED ONLY FROM PGIOT WITH UCHN SETUP
	POPJ P,			; ONLY THE DD UUO IS LEGAL FROM A NON-DISPLAY
	MOVEI AC3,DPYLEN
	PUSHJ P,UFSGET
	MOVE DDB,AC1
	SETOM DPRLSF(DDB)
	SETOM PRGNUM(DDB)
	SETZM PRGCNT(DDB)	; CAN'T BE ANY OVERLAP IN PROGRESS - RPH 10-5-72
	HRLI DDB,DDDLIN		; PUT IN DISPLAY-TYPE BIT (DD)
	JRST CPOPJ1		; SUCCESS
;PPIOT

;;MORE GENERAL UUO ROUTINES.

↑PPIOT:	PUSHJ P,PRGFND		;FIND APPROPRIATE DPY PRGM.
	POPJ P,			;IGNORE IF NOT DISPLAY
	MOVE DAT,CURPP(DDB)	;GET PTR. TO CURRENT P OF P.
	HLL DAT,DDB		; PUT IN FLAG BIT
	CAIG UCHN,MPPIOT	;DOES FUNCTION EXIST ?
	JRST @PPIOTX(UCHN)	;YES.
	JRST UUOERR

DEFINE UUOS{FOR X IN(PPSEL,PPACT,<DPYPOS,,PPYPOS>,<DPYSIZ,,PPXSIZ>
,PPREL,PPINFO,LEYPOS,PPHLD)}

PSHSYS
LOSYS

UUOMAC PPIOTX,PPIOT
MPPIOT←←UUOCNT-1

POPSYS
;DPYCLR DPYRST PPCLR PPC1 PPC2 PPC3

;RESET DPY, CLEARS PP AND POG. (UUO LEVEL)

↑DPYCLR:JUMPE	UCHN,DPYRST	;NON-ZERO AC FIELD MEANS SELECT OTHER DPY.
	JSP	AC3,FNDJOB	;GET JOB NO. (FNDJOB IS IN MAIL-UUOCON).
	EXCH	DAT,J		;PRETEND IT'S OURS.
	PUSHJ	P,PRGFND	;FIND ASSOCIATED DPY PRGM.
	POPJ	P,		;SHOULDN'T LOSE ANY MORE THAN ANYONE ELSE
	MOVEM	DDB,DPYMAP(DAT)	;ENTER IN OUR TABLE.
	POPJ	P,		;WE WILL NOW USE OTHER GUY'S DPY PRGM.

↑DPYRST:SETZM DPYMAP(J)
	PUSHJ P,PRGF1		;FIND DPY PRGM FOR JOB IN J.
	SKIPA			;FOUND. WE WILL RESET IT TO INITIAL STATE.
	POPJ P,			;NO PRGM.
	PUSHJ P,PGCLR		;FIRST FLUSH ALL PIECES OF GLASS.
↑PPCLR:
IFN FTDM,<
	PUSH P,PRGACT(DDB)	;Remember former PP activation state
>;
	MOVEI UUO,17		;NOW ALL PIECES OF PAPER EXCEPT 0.

; PPREL SELECTS P OF P 0 (UUO←0) IF IT RELEASES A P OF P
;   WHICH IS CURRENTLY SELECTED, AND NOT 0, SO.....
	PUSH P,UUO		;PPREL MAY CLOBBER UUO.
PPC1:	PUSHJ P,PPREL		;RELEASE P OF P.
	SOSE UUO,(P)		;NEXT
	JRST PPC1		;YES
	HLL DAT,DDB		; PUT IN BIT FOR DISPLAY TYPE
	MOVEM DDB,(P)		; SAVE PROGRAM HEADER ADDRESS
	PUSHJ P,PPSEL		;SELECT P OF P 0.
IFN FTDM,<
	POP P,DDB		;Dpy header and bits
	MOVE UUO,DDB
	EXCH UUO,(P)		;Save dpy header on stack--old PP act bits in UUO
PPC3:	TRNE UUO,400000		;Was PP 0 on before?
	JRST PPC2		;Yes, don't redraw it now
	TLNE DDB,DMLIN		;Enter here from PPNST2 to redraw screen on BRK N
	SETZM DMLAST(DAT)	;Make sure whole screen gets redrawn on DM
	SETOM PGSIZ(DAT)	;Make PPXSIZ redraw screen (all dpys)
>;FTDM
IFE FTDM,<
PPC3::
>;¬FTDM
;Enter here from PPNSET, called from ESC N & BRK N commands to redraw current PP
PPC2:	MOVE DDB,(P)		; PICK UP PROGRAM HEADER
	SETZ UUO,		; CLEAR LINE EDITOR POSITION
	PUSHJ P,LEYPOS
	SETZ UUO,
	PUSHJ P,PPHLD		; RESET HOLDING STATUS
	MOVEI UUO,YPDD		; DATA DISC DEFAULT Y POSITION
	TLNE DDB,DMLIN
	MOVEI UUO,YPDM		; DATAMEDIA DEFAULT Y POSITION
	TLNE DDB,DISLIN
	MOVEI UUO,YPIII		; III DEFAULT Y POSITION
	PUSHJ P,PPYPOS
	POP P,DDB
	MOVEI UUO,NGSIII*1000+NLSIII	;DEFAULT GLITCH AND SCREEN SIZE FOR III
	TLNE DDB,DMLIN
	MOVEI UUO,NGSDM*1000+NLSDM	;DEFAULTS FOR DATAMEDIA
	TLNN DDB,DDDLIN
	JRST PPXSIZ		;NOT DD, JUST SET SCREEN DEFAULTS AND BE DONE
	MOVEI UUO,NGSDD*1000+NLSDD
	PUSHJ P,PPXSIZ
	HRRZ TAC,PRGNUM(DDB)
	SUBI TAC,DDL0
	PUSHJ P,VDRST1		;EXTRA VIDEO DIDDLING FOR DD
	JRST VDOUT
;PPNSET PPNST1 PPNST2 SETPHD PPGSET PPGST1

;Clock level routines to carry out line editor escape commands.

PPNST2:	TDZA UUO,UUO		; HERE FROM <BRK>N--FORCE REDRAWING PP
↑PPNSET:			; CALLED FROM <ESC>N
	MOVEI UUO,400000	; Don't redraw unless necessary
	PUSHJ P,SETPHD		; SET UP DDB AND DAT PROPERLY
	PUSH P,[PPNST1]		;Routine to call after PPC2
	PUSH P,DDB
	JRST PPC3		;Normalize size and position of current PP

PPNST1:	SETO AC1,		; MARK SIZE AND Y-POSITION SET BY USER
	DPB AC1,SIZSBU
	DPB AC1,POSSBU
	POPJ P,

SETPHD:	HRRZ DDB,DAT		; PUT PROGRAM HEADER ADDRESS IN DDB
	MOVE DAT,CURPP(DDB)
	HLL DDB,PPDPY(DAT)	; GET BIT INDICATING DISPLAY TYPE
	HLL DAT,DDB
	POPJ P,

↑PPGSET:			; CALLED FROM <ESC>G TO SET NUMBER OF GLITCHES.
	PUSHJ P,SETPHD
	MOVEI AC3,NGSDD
	TLNE DAT,DISLIN
	MOVEI AC3,NGSIII
	TLNE DAT,DMLIN
	MOVEI AC3,NGSDM
	SKIPN UUO,LEARG(DDB)	; PICK UP NUMBER OF GLITCHES REQUESTED
	MOVE UUO,AC3		; NO ARG, USE DEFAULT
	LSH UUO,=9		; PUT IN LH OF RH
	ADD UUO,DEL(DAT)
PPGST1:	PUSHJ P,PPXSIZ		; SET IT
	SETO AC1,
	DPB AC1,SIZSBU		; NOTE SIZE WAS SET BY USER
	POPJ P,
;PPLSET PPYSET PPYS2 PPYDD PPYDM PPYS3 PPYIII

; CALLED FROM <ESC>L IN LINE EDITOR. SETS LINES/GLITCH

↑PPLSET:
	PUSHJ P,SETPHD
	MOVEI AC3,NLSDD
	TLNE DAT,DISLIN
	MOVEI AC3,NLSIII
	TLNE DAT,DMLIN
	MOVEI AC3,NLSDM
	MOVE UUO,PGSIZ(DAT)	;Maintain number of glitches per screen
	LSH UUO,=9		; w/old number in lh of RH
	SKIPN AC2,LEARG(DDB)
	MOVE AC2,AC3
	ADD UUO,AC2		;Lines per glitch in rh of RH
	JRST PPGST1

; CALLED FROM <ESC>Y IN LINE EDITOR. SETS Y POSITION

↑PPYSET:
	PUSHJ P,SETPHD
	MOVE UUO,LEARG(DDB)
	JUMPL DDB,PPYIII
	TLNE DDB,DMLIN
	JRST PPYDM
PPYDD:	MOVEI AC3,YPDD
	LSH UUO,7
	IDIV UUO,[-5]
PPYS3:	ADDI UUO,1000
PPYS2:	CAIL UUO,1000
	MOVEI UUO,(AC3)		;SET TO NORM ON ZERO (NULL) ARG
	PUSHJ P,PPYPOS
	SETO AC1,
	DPB AC1,POSSBU
	POPJ P,

PPYIII:	MOVEI AC3,YPIII
	IMUL UUO,[-30]
	ADDI UUO,770+30
	JRST PPYS2

PPYDM:	MOVEI AC3,YPDM		;Pick up default Y-position for Datamedia
	LSH UUO,7		;Convert line number to number from -1000 to 1000
	IDIV UUO,[-3]		; by multiplying by -2000/=24 and adding 1000
	JRST PPYS3
;PPHLD PPHLD1 PPHLD2 AC1CLK

; SET PAGE PRINTER HOLD COUNTS. GIVE LINE COUNT IN BITS 18-26 AND
; GLITCH COUNT IN 27-35. HIGH ORDER BIT OF FIELD ON MEANS DO NOT SET.

PPHLD:	SETZ AC1,
	TRNE UUO,1B18		; DOES HE WANT TO SET LINE COUNT?
	JRST PPHLD1		; NO, SKIP IT
	DPB AC1,LHCSBU		; NOTE SET BY UUO
	LDB AC2,[POINT 8,UUO,26];used to say 25 instead of 26--ME 8-19-73
	DPB AC2,HLINES		; SET INTO PROGRAM HEADER
	SKIPN AC2		; ZERO MEANS DON'T HOLD AT ALL
	SETO AC2,		; WHICH IS SIGNIFIED BY -1
	MOVEM AC2,LHCNT(DDB)	; START IT GOING NOW
PPHLD1:	TRNE UUO,1B27		;used to say 1b26--ME 8-19-73
	JRST PPHLD2		; NOW GO UNHOLD US
	DPB AC1,GHCSBU
	LDB AC2,[POINT 8,UUO,35]
	DPB AC2,HGLTCH
	SKIPN AC2
	SETO AC2,
	MOVEM AC2,GLHCNT(DDB)
PPHLD2:	SETZ AC1,
	EXCH AC1,DPHOLD(DDB)
	JUMPE AC1,CPOPJ
	HRRZ AC1,PRGNUM(DDB)
	HRLI AC1,UNHOLD
AC1CLK:	CONO PI,PIOFF
	IDPB AC1,CLKQ
	CONO PI,PION
	POPJ P,
;PPSPY, PPINFO    PPSPY2 PPINF1 PPINF1 PPSPY1

; THIS ROUTINE GIVES THE USER A NICE LITTLE TABLE OF DATA ABOUT HIS
; PAGE PRINTER. THE TABLE IS =20 WORDS LONG. THE FIRST WORD IS
; XWD <POG ACT BITS>,<PP ACT BITS> WHICH ARE IN PPACT OR PGACT FORMAT.
; THE SECOND WORD IS THE NUMBER OF THE PIECE OF PAPER CURRENTLY SELECTED.
; THE THIRD WORD IS THE LINE EDITOR POSITION IN THE RH, BIT ZERO IS
; THE PAGE COLOR, AND BIT 1 SAYS WHETHER <ESC>C HAS BEEN TYPED SINCE YOU
; LAST GAVE THIS UUO, BIT 2 IS ON IF YOU ARE A DATA DISK DISPLAY.
; THE FOURTH THROUGH THE 19.TH WORDS ARE XWD <Y-POS>,<NG*1000+LPG> WHERE
; NG IS THE NUMBER OF GLITCHES AND LPG IS THE NUMBER OF LINES PER GLITCH.
; THIS IS CLEVERLY ARRANGED SO THAT A PPYPOS UUO WITH THE ARGUMENT
; IN THE LH OF THIS WORD FOLLOWED BY A PPXSIZ WITH THE ARGUMENT IN
; THE RH OF THIS WORD COMPLETELY RESTORES THAT PAGE.
; THE 20TH WORD IS A COPY OF GWORD. B0 MEANS PAGE PRINTER SIZE SET LAST
; BY USER COMMAND RATHER THAN BY UUO, B1 FOR Y-POSITION, B2 FOR LINE HOLD COUNT,
; AND B3 FOR GLITCH HOLD COUNT. BITS 9-17 HAVE THE ACTUAL LINE HOLD COUNT
; AND BITS 18-25 HAVE THE ACTUAL GLITCH HOLD COUNT. ZERO IF NOT BEING USED.

↑PPSPY:	HRR	UUO,TAC		;VERSION OF PPINFO FOR ANOTHER JOB'S DPY
	HLRE	J,TAC		;ARG IS JOB#,,OUTPUT BLOCK ADDR
	JUMPL	J,PPSPY1	; OR - LINE # IN LH
	JUMPE	J,CPOPJ		;NON-SKIP RETURN IF NO JOB OR NO DPY
	CAIL	J,JOBN
	POPJ	P,
	MOVE	AC1,JBTSTS(J)
	TLNN	AC1,JNA
	POPJ	P,
	PUSHJ	P,PRGF1		;USE PRGF1 TO OUTFLANK DPYMAP HACK IN PRGFND
PPSPY2:	SKIPA	DAT,CURPP(DDB)	;PRGF1 SKIP RETURNS ON FAILURE
	POPJ	P,		;NO DISPLAY
	HLL	DAT,DDB
	AOS	(P)		;OK, SET SKIP RETURN AND DROP THROUGH

PPINFO:	MOVE	AC1,PRGACT(DDB)		;PICK UP HIS ACTIVATION BITS
	XCTR	XW,[MOVEM AC1,(UUO)]
	MOVE	AC1,PPNO(DAT)		;GET CURRENT PIECE OF PAPER NUMBER
	XCTR	XW,[MOVEM AC1,1(UUO)]
	LDB	AC1,[POINT 11,LEPOS(DDB),21]
	TRNE	AC1,1⊗=10		;EXTEND SIGN BIT
	ORI	AC1,-1⊗=10
	MOVE	AC2,DDCW(DAT)		;PUT IN BLACK-WHITE BIT
	TLNE	AC2,(1B5)
	TLO	AC1,(1B2)
	MOVEI	AC2,0			;PUT IN <ESC>C BIT
	EXCH	AC2,LECC(DDB)
	SKIPE	AC2
	TLO	AC1,(1B1)
	MOVSI	AC2,DDDLIN!DMDLIN!DISLIN
	AND	AC2,DDB			;SET ONLY APPROPRIATE DISPLAY BIT IN AC2
	OR	AC1,AC2
	XCTR	XW,[MOVEM AC1,2(UUO)]
	ADDI	UUO,3
	MOVSI	AC1,(UUO)		;ZERO OUT THE RESET OF THE TABLE
	HRRI	AC1,1(UUO)
	XCTR	XW,[SETZM (UUO)]
	XCTR	XBLTRW,[BLT AC1,17(UUO)];BLT USER TO USER, MAKING ZEROES
	HLRZ	AC1,PPCALL(DDB)		;POINTER TO FIRST PAGE PRINTER CONTROL BLOCK
PPINF1:	LDB	AC2,[POINT 11,PPOSV(AC1),21]
	TRNE	AC2,1⊗10		;SPREAD SIGN BIT ALL DOWN WORD
	OR	AC2,[-1⊗10]
	LSH	AC2,=9			;MOVE IT OVER
	ADD	AC2,PGSIZ(AC1)		;PUT IN THE NUMBER OF GLITCHES
	LSH	AC2,=9
	ADD	AC2,DEL(AC1)		;AND THE NUMBER OF LINES PER GLITCH
	MOVE	AC3,PPNO(AC1)		;PICK UP THE PIECE OF PAPER NUMBER
	ADD	AC3,UUO
	XCTR	XW,[MOVEM AC2,(AC3)]	; GIVE HIM THE WORD
	HRRZ	AC1,LINK(AC1)		;LINK TO NEXT PAGE PRINTER CONTROL BLOCK
	JUMPN	AC1,PPINF1		;LOOP AROUND IF THERE IS ONE
	MOVE	AC1,GWORD(DDB)		;PICK UP GARBAGE DUMP WORD
	XCTR	XW,[MOVEM AC1,=19-3(UUO)]
	POPJ	P,

PPSPY1:	MOVM	J,J			;NEGATIVE ARG TO PPSPY IS LINE #
	MOVE	DDB,LINTAB(J)
	TLNN	DDB,DISLIN!DDDLIN!DMLIN
	POPJ	P,
	HRRZ	DDB,LETAB(J)
	JUMPE	DDB,CPOPJ		;NO DPY HEADER
	PUSHJ	P,PRGF3			;SETS UP DISPLAY-TYPE BIT IN DDB
	JRST	PPSPY2
;LEYPOS

; THIS IS THE ROUTINE FOR A UUO WHICH SETS YOUR LINE EDITOR'S VERTICAL
; POSITION. THE EFFECTIVE ADDRESS OF THE UUO IS SAID POSITION IN
; PPYPOS FORMAT. Y-POSITION OF ZERO IS VERBOTTEN AND MEANS RETURN TO
; THE BOTTOM OF THE PAGE PRINTER.

LEYPOS:	MOVE AC1,[BYTE (11)<-777>,0(3)0,0(2)1,2(3)3]
	TRNN UUO,-1		; IS THE POSITION ZERO?
	SKIPA AC1,[DISNOP]	; YES, PUT A NO-OP IN
	DPB UUO,[POINT 11,AC1,21]
	MOVEM AC1,LEPOS(DDB)	; PUT IT IN BEFORE THE LINE EDITOR CALL
	JUMPL DAT,CPOPJ		;THAT'S ALL IF III
	SETO AC1,		; QUEUE UP A LINE EDITOR REQUEST TO GET IT REPOSITIONED
	EXCH AC1,LECLK(DDB)
	JUMPN AC1,CPOPJ
	HRR AC1,DDB
	HRLI AC1,DPLED
	JRST AC1CLK		;Plant clock request from AC1
;FOOFRL FREEL

;;FREEL FREES A LIST OF BLOCKS POINTED TO BY AC1, AND UPDATES
;; THE USER'S BLKTOT.  

FOOFRL:	HRRZ AC1,UUO
	PUSHJ P,FSGIVE
	HRRZ AC1,TAC1
	JUMPE AC1,CPOPJ
FREEL:	HRRZ AC3,LINK(AC1)	;GET CDR OF LIST.
	PUSHJ P,CGIVFS		;FREE CAR OF LIST.
	MOVEM AC3,AC1
	JUMPN AC1,FREEL		;FREE CDR.
	POPJ P,
;DMUPG CHASEM CHASE3

DMUPG:
IFE FTDM,<
	PUSHJ P,NODMDP		;CAN'T GET HERE I CLAIM!--ME
	JRST 4,AUTOLOAD
>;¬FTDM
IFN FTDM,<
	XCTR XR,[MOVE AC1,(UUO)]	;Get flag word and pointer to program
	TLNE AC1,CHASTE			;Want to flush any previous program of ours?
	PUSHJ P,CHASEM			;Yes, do it first
	XCTR XR,[MOVM AC3,1(UUO)]	;LENGTH OF PRGM.
	JUMPE AC3,DDWAIT		;Length 0 means just wait for previous xfer
	XCTR XR,[SKIPGE AC1,(UUO)]	;Skip unless overlapped mode requested
	XCTR XW,[SETZM 2(UUO)]		;Initialize run flag and write check it
	ADDI AC1,-1(AC3)
	XCTR XR,[MOVE AC2,(AC1)]	;Address check end of program
	PUSHJ P,FSGET			;Get FS block to hold whole program
	JFCL				;UUO level--can't lose
	XCTR XR,[HRLZ TEM,(UUO)]	;STARTING ADDR. OF PRGM.
	HRR TEM,AC1			;Gonna BLT the program into FS
	HRLI AC1,440700
	PUSH P,AC1
	XCTR XR,[MOVM AC3,1(UUO)]	;Get length again
	ADDI AC1,-1(AC3)		;Final address of BLT
	XCTR XBLTR,[BLT TEM,(AC1)]	;Dpy program into Free Storage
	PUSHJ P,GETQ			;Get DD block for queueing transfer
	SETZM QXY(AC1)			;No assumed X-Y position
	IMULI AC3,5			;Number of chars
	MOVEM AC3,QDMCNT(AC1)
	POP P,QTAKR(AC1)		;Byte pointer for ch 5 unpacking text
	XCTR XR,[HLRZ AC3,(UUO)]	;Get user flags
	TRNE AC3,400000			;Overlapped mode?
	XCTR XW,[AOSA 2(UUO)]		;Yes, count a transfer running
	TDZA AC2,AC2			;No
	MOVEI AC2,2(UUO)
	MOVEM AC2,QPUTR(AC1)		;Address of user's run flag, if any
	ANDI AC3,DMUMSK			;Mask of legally set user flags
	IORI AC3,DMXUSR			;Flag block as user program request
	HRL AC3,DDB
	MOVEM AC3,QFLAGS(AC1)		;Dpy header address,,user flags
	MOVEI AC2,PRGCNT(DDB)		;PICK UP ADDRESS OF COUNT FIELD
	MOVEM AC2,QCOUNT(AC1)
	AOS PRGCNT(DDB)			;Set up our wakeup counter
	MOVEM J,QWAKE(AC1)		;Job to wake up
	MOVSM J,QXYLOC(AC1)		;Mark this as our xfer--for easy flushing
	HRRZ AC3,QTAKR(AC1)
	HRLI AC3,DMUDUN			;Routine to call when xfer done--returns FS
	MOVEM AC3,QFREE(AC1)		;Address of FS block to return later
	MOVEI AC2,DMUSER-QLINK(DDB)	;Address of header for DM user prog queue
	PUSHJ P,QDM			;Queue up the xfer
	MOVEI DAT,(DDB)
	JRST STRTDM			;Now start DM tty

;Here to flush all of our requests from user queue.
CHASEM:	OFFSCN				;Don't let anything change while we think.
	SKIPA TAC,DMUSER(DDB)		;Get pointer to first entry in queue
CHASE3:	POP P,TAC
	ANDI TAC,-1
	CAIN TAC,DMUSER-QLINK(DDB)	;Does this pointer point to header?
	JRST SCNONJ			;Yes, all done
	PUSH P,QLINK(TAC)		;Remember pointer to next queue entry
	MOVE AC1,QFLAGS(TAC)		;Get flag word
	MOVS AC2,QXYLOC(TAC)		; and owner of request
	CAIN AC2,(J)			;Our job number?
	TRNN AC1,DMXUSR			;One of ours?
	JRST CHASE3			;No
	MOVS AC1,QFREE(TAC)		;Exit routine
	EXCH J,DDB			;Routine expects dpy header in J
	PUSHJ P,(AC1)			;Call exit routine
	EXCH J,DDB
	PUSHJ P,DEQ			;Dequeue this entry.
	JRST CHASE3
;DMUDUN DMUCLK QDM QDMPP QDMGLC

;Here in CH5 when user display program has finished. (Can't clobber RH TAC or RH J.)
DMUDUN:	HRRZ AC1,QFREE(TAC)		;Address of FS block containing user prog
	PUSHJ P,FSGIVE
	SKIPLE AC1,QWAKE(TAC)		;Job number
	SKIPN AC2,QPUTR(TAC)		;Any run flag?
	POPJ P,				;No
	CAIL AC1,JOBN			;Legal job number?
	POPJ P,
	HRL AC2,AC1			;<JOB>,,<RUN FLAG ADDRESS>
	MOVEM AC2,UCOUNT(J)		;Into dpy header for clock routine.
	HRLI J,DMUCLK
	CONO PI,PIOFF
	IDPB J,CLKQ
	CONO PI,PION
	POPJ P,

;Here in CH7 to see if user is in core and SOS his run flag if so.
DMUCLK:	HLRZ J,UCOUNT(DAT)		;Get job number from dpy header
	JUMPE J,CPOPJ
	MOVSI AC1,SWP
	TDNE AC1,JBTSTS(J)
	JRST DPYTIM			;Swapped out, replant clock request
	PUSHJ P,MAPSET
	HRRZ AC2,UCOUNT(DAT)		;Address of user's count cell
	XCTR XRW,[SOS (AC2)]
	POPJ P,

;QDM is general routine to add an entry at the end of any queue (DM).
;Pointer to header needed in AC2, pointer to new queue entry in AC1.
;QDMPP is routine used by page printer.
;QDMGLC is routine used by DM glitching

QDMGLC:	MOVSI AC2,DPYTYP
	HRR AC2,PRGNUM(DDB)		;Line number is datum for DPYTYP
	MOVEM AC2,QWAKE(AC1)
	JRST QDMPP2

QDMPP:	MOVEM DAT,QWAKE(AC1)		;Put in address of clock req to DPYTYP or LERELE
	HRRM TAC1,QWAKE(AC1)		;Put in data (line number of dpy header)
QDMPP2:	HRLM DDB,QFLAGS(AC1)		;Dpy header
	MOVEI AC2,PPENQ(UUO)		;Cell to count down when done
	MOVEM AC2,QCOUNT(AC1)
	AOS PPENQ(UUO)			;Count it up now
	MOVEI AC2,DMPPPT-QLINK(DDB)	;Address of queue header
	AOS NPPXFR(DDB)			;COUNT A PP TRANSFER IN PROGRESS
	MOVEI AC3,NPPXFR(DDB)
	TLOA AC3,(<SOS>)		;PREPARE TO COUNT DOWN PP TRANSFERS
↑QDM:	MOVSI AC3,(<JFCL>)
	MOVEM AC3,QINSTR(AC1)
	OFFSCN				;Don't let scanner get in and diddle queue
	HLRZ AC3,QLINK(AC2)		;Get pointer to end of queue
	HRRM AC1,QLINK(AC3)		;Make last entry point forw to new one
	HRL AC3,AC2
	MOVSM AC3,QLINK(AC1)		;Insert forw and back ptrs in new entry
	HRLM AC1,QLINK(AC2)		;Make header point back to new entry
	ONSCN				;Turn scanner channel back on
	POPJ P,
>;FTDM
;;UPGIOT IS THE DEMOCRATIC UUO WHICH ALLOWS ALL MEN,
;; HOWEVER HUMBLE THEIR STATION (PROVIDED IT IS A DISPLAY),
;; TO RUN THEIR VERY OWN DISPLAY PROGRAMS.

↑UPGIOT:	BEGIN UPG

T2←DSER
PBSZ←←CNT	;DPY INSTRS /BLOCK.
SIZE←←=17
PGWC←←0
PGSA←←1
PGNP←←2

	PUSHJ P,PGSET		;GET REQUESTED P OF G .
	POPJ P,			;NO SUCH DPY, LEAVE NOW
	TLNE DDB,DDDLIN
	JRST DDUPG		;RUN DD PROGRAM
	TLNE DDB,DMDLIN
	JRST DMUPG		;RUN DM PROGRAM
	MOVEM J,CURPG(DDB)
	XCTR XR,[HRLZ TEM,(UUO)]	;STARTING ADDR. OF PRGM.
	XCTR XR,[MOVM AC3,1(UUO)]	;LENGTH OF PRGM.
	CAIL AC3,NBS*PBSZ	;IS PIECE OF GLASS GOING TO BE TOO BIG ?
	JRST UPGTB
	HRLZM AC3,UCHN		;SAVE WC IN LEFT OF UCHN, MAKE RIGHT HALF 0 FOR NOW.
	MOVEI TAC,PBSZ-1+PGNP(AC3)
	IDIVI TAC,PBSZ		; FIND OUT HOW MANY BLOCKS THIS PROGRAM WILL CONSUME
	MOVEI T2,(TAC)
	SUB TAC,SIZE(J)		;HOW BIG IS THIS PG NOW ?
	ADD TAC,BLKTOT(DDB)	;THIS IS HOW MUCH IT GROWS.
	JUMPG TAC,UPGER1	;IS USER OVER HIS ALLOTMENT ?
	HRREI TAC,-1(T2)	;SAVE IT.
	SETZM SIZE(J)		;...SEE FOLLOWING INSTR.
	MOVEI TAC1,DISNOP	;SEE FOLLOWING INSTR...
	JUMPE AC3,UPREL1	;IF WC IS 0, RELEAS PAGE.
	MOVEI AC3,NBS+2		; NICE BIG PIECE
	PUSHJ P,UGETF1		;GET BLOCK FOR THE RELOCATION TABLE.
	JUMPL AC1,CPOPJ		;IF WE ARE AT SPACEWAR LEVEL AND NO FREE STG., JUST RETURN.
	MOVEM AC1,UUO
	MOVEI TAC1,0
	TLOA UUO,TAC		;MAKE UUO AN INDEXED POINTER TO REL. TBL.
L1:	MOVEM AC1,TAC1		;SAVE LOC. OF THIS BLOCK.
	PUSHJ P,CGETFS		;GET A BLOCK OF FREE STG.
	JUMPL AC1,FOOFRL	;GO AWAY IF SPACEWAR AND NO FREE STG.
	MOVSM AC1,@UUO		;ENTER IN RELOCATION TABLE.
	MOVEM TAC1,LINK(AC1)	;LINK TO PREVIOUS BLOCK.
	SOJGE TAC,L1		;GET REST OF BLOCKS NEEDED.
	MOVEM T2,SIZE(J)	;UPDATE SIZE OF THIS PG.
;LOOP UPGTB SPECOP DONE UPREL1

	MOVN TAC1,UCHN		;LENGTH OF USERS CODE.
	HLR TAC1,TEM		;STARTING ADDR.
	HRR UCHN,UUO		;BOTTOM OF RELOCATION TABLE.
	HLRZ T2,(UUO)
	ADD UCHN,[XWD PGNP,0]
	HLRZM UCHN,PGWC(T2)
	HLRZM TEM,PGSA(T2)
	ADD T2,[XWD -PBSZ+PGNP,PGNP]
	TDZA			;11/19/74  ME  DON'T CHECK THE FIRST WORD OF PROG
LOOP:	XCTR XR,[MOVE (TAC1)]	;PICK UP WORD FROM PRGM.
	TRNN 3			;DOES IT NEED EXAMINING ?
	PUSHJ P,SPECOP		;YES, IT IS A POTENTIALLY DANGEROUS INSTR.
	MOVEM (T2)		;STORE THE INSTR.
	AOBJP TAC1,DONE		;AT END OF PGM. ?
	AOBJN T2,LOOP		;NO. END OF BLOCK ?
	MOVE 1(UCHN)		;YES. GET START OF NEXT ONE.
	HRRI DISJMP		;FORM JMP INSTR. TO IT.
	MOVEM (T2)		;PLACE AT END OF LAST BLOCK.
	ADD [XWD 1,0]		;MAKE JMP GO TO 2ND WORD OF NEW BLOCK..
	MOVEM 1(T2)		;...IN CASE THERE IS A TSS WHICH SKIPS..
	HLR T2,1(UCHN)		;GET START OF CURRENT BLOCK.
	HRLI T2,-PBSZ		;LENGTH OF BLOCK.
	AOJA UCHN,LOOP		;GO FILL NEXT BLOCK.

UPGTB:	ERMS {PIECE OF GLASS TOO BIG.}
	POPJ P,
	
SPECOP:	LDB AC1,[POINT 3,0,33]	;GET OPCODE.
	XCT SPCTBL(AC1)		;DO APPROPRIATE THING.
	POPJ P,			;STORE INSTR.

DONE:	MOVE TAC1,(UUO)		;START OF BLOCK 0 OF PRGM.
	ADD TAC1,[XWD PGNP,DISJMP]
	MOVEM TAC1,1(T2)	;MAKE END OF PGM JMP BACK TO START.
	MOVEM TAC1,2(T2)
	HRRZ AC1,UUO		;NOW RELEASE THE RELOC. TABLE.
	PUSHJ P,FSGIVE
	HRRI TAC1,DISJSR	;JSR TO START OF PGM.
↑UPREL1:HLRZ AC1,PGCALL(DDB)
	SUBI AC1,(J)		;GET NEG POG #
	MOVSI AC2,400000
	LSH AC2,(AC1)		;MAKE PGACT BIT
	TRNE TAC1,20
	IORM AC2,PRGACT(DDB)	;IS JSR - MARK ACTIVE
	TRNN TAC1,20
	ANDCAM AC2,PRGACT(DDB)	;IS NOP - MARK INACTIVE
	EXCH TAC1,(J)		;EXCHANGE FOR OLD ONE.
	HLRZS AC1,TAC1		;GET START OF OLD PRGM.
	JUMPE TAC1,CPOPJ	;RETURN IF NO OLD PRGM.
	  ;FREE THE OLD PRGM.,AND FIX PRGM TO RESTART AT TOP.
	SUBI AC1,PGNP
	JRST SETRST		;SETRST IS IN PRINT.
;SPCTBL SELCHK LOOPS DCHNOK

;;MORE OF UPG.

;;SPCTBL IS DISPATCH TABLE FOR HANDLING SPECIAL DPY INSTRS.

SPCTBL:	JRST HLTOP	;HALT
	JRST ILLJMS	;JMS
	JRST SELCHK
	JRST ADRRST	;RST (NO BITS ON -- NOOP) (DCS-5/29/70)
	JRST ADROP	;JMP
	JRST ADROP	;JSR OR SAVE
	JRST SELCHK
	JRST ADROP 	;RST (AGAIN.)

SELCHK:	MOVE TAC,JOB
	MOVE TAC,JBTPRV(TAC)
	TLNE TAC,UPGPRV			;RETURN QUICK IF HE HAS THE PRIV
	POPJ P,				;HE HAS THE PRIVILEGE
	MOVE TAC,[<77770010>⊗DPYNUM]	;DESELECT ANYONE.
	MOVEI AC2,DPYNUM-1		;DPY'S ONLY.
	PUSH P,TAC1
LOOPS:	LSH TAC,-1			;SHIFT MASK.
	SKIPN AC3,TTYTAB+DPYL0(AC2)	;POINTER TO DPY DDB.
	JRST DCHNOK			;SELECT OK!
	MOVE TAC1,DEVMOD(AC3)
	LDB AC3,[POINT 6,1(AC3),5]	;GET # OF JOB THAT HAS THAT DPY.
	TDNE TAC1,[XWD TTYATC,ASSCON!ASSPRG]
	CAMN AC3,JOB(PID)		;THIS ONE?
DCHNOK:	TLO TAC,400000			;SELECT BIT.
	SOJGE AC2,LOOPS
	POP P,TAC1
	MOVSI AC2,400000		;GET A BIT.
	MOVN AC3,PRGNUM(DDB)		;TTY NUMBER (DPYL0 TO DPYL0+DPYNUM-1)
	LSH AC2,DPYL0(AC3)
	TDO TAC,AC2			;MAKE SURE HE GETS HIS OWN.
	AND TAC
	POPJ P,
;ADRRST ADROP ILLAD ILL1 ILLJMS HLTOP UPGER1

; RST WITH NO PARAM BITS ON IS A NOOP -- ALLOW ANY ARGUMENT
; TO APPEAR UNCHANGED IN THE LEFT HALF

ADRRST:	TRNN	60		;SIZE OR [X,Y] FIELDS ON?  (DCS-5/29/70)
	 POPJ	 P,		; NO, LEAVE IT ALONE	   (DCS)

;CALL ADROP WITH THE FOLLOWING
;	0	XWD <ADDRESS TO CHECK>,<ANYTHING>
;	TEM	XWD <USER BASE ADDRESS>,<ANYTHING>
;	UCHN	XWD <LENGTH OF USER BUFFER>,<ANYTHING>
;	UUO	XWD TAC,<ADDRESS OF RELOCATION TABLE>
;	TAC1	XWD <ANYTHING>,<ADDRESS TO TYPE OUT ON ERROR>

ADROP:	SUB TEM			;AN ADDRESSABLE INSTR. UNRELOCATE IT.
	CAML UCHN		;ADDRESS TOO HIGH ?
	JRST ILLAD		;YUP.
	ADD 0,[XWD PGNP,0]	; SKIP OVER HEADER WORDS
	HLRE AC1,0		; PICK UP ADDRESS
	IDIVI AC1,PBSZ		; GET # BLOCKS AND DISPLACEMENT INTO LAST BLOCK
	HRL 0,AC2		; USE DISPLACEMENT INTO BLOCK PLUS ADDRESS OF BLOCK
	MOVE TAC,AC1
	ADD @UUO		;ADD IN RIGHT RELOCATION.
	JUMPGE AC1,CPOPJ	;WAS ADDRESS TOO SMALL ?
ILLAD:	PUSHJ P,DPYERR		;ILLEGAL ADDRESS IN DPY INSTR.
	ERMS {ILLEGAL INSTR. ADDRESS.}
ILL1:	MOVEI DISNOP		;REPLACE OFFENDING INSTR. WITH NOP.
	POPJ P,

ILLJMS:	PUSHJ P,DPYERR
	ERMS {JMS NOT LEGAL; USE JSR.}
	JRST ILL1

HLTOP:	MOVE (UUO)		;REPLACE HLT WITH RETURN JMP.
	ADD [XWD PGNP,DISJMP]
	POPJ P,

UPGER1:	ERMS {TOTAL DPY BUFFER SPACE EXCEEDED.}
	POPJ P,
;DDUPG DDCWL DDCINC DDWAIT APRONJ

; DATA DISC PROGRAM HANDLER
; SENDS THE PROGRAM DIRECTLY OUT OF LOSER CORE IN EXEC MODE

;EXTENDED FEATURES:
;BIT 0 OF HEADER WD 0 => OVERLAPPED XFER (RETURNS WITHOUT WAITING)
; IN THIS MODE HEADER WD 2 ≠ 0 => XFER GOING.
; DPYOUT ALWAYS WAITS FOR PREV XFER, SO DPYOUT WITH WC=0 WILL
; WAIT FOR BUFFER TO BE AVAIL.
;BIT 1 OF HEADER WD 0 => DOUBLE FIELD MODE, WHICH DOES XFER
; TWICE - ONCE ON EACH FIELD. HEADER WD 3 SHOULD POINT TO WORD
; OF BUFFER CONTAINING (ONLY) LOW-ORDER LINE ADDRESS SELECT
; AS 3RD COMMAND BYTE. THIS BYTE WILL BE ADJUSTED TO APPROP
; FIELD ON EACH XFER.

DDUPG:	SKIPE DDOFF		; DO WE HAVE A DATA DISC TODAY
	POPJ P,			; NO, SPEAK NO EVIL!
	PUSHJ P,DDWAIT		;WAIT FOR PREV XFER, IF ANY
	XCTR XR,[SKIPGE AC1,(UUO)]	; PICK UP ADDRESS OF USER BUFFER
	XCTR XW,[SETZM 2(UUO)]		; INIT XFER IN PROGRESS FLAG IF USED
	XCTR XR,[SKIPG AC2,1(UUO)]	; PICK UP WORD COUNT OF BUFFER
	POPJ P,			;THAT WAS EASY
	ADDI AC2,-1(AC1)	; MAKE POINTER TO LAST WORD
	XCTR XR,[SKIPE (AC2)]	;DON'T CLOBBER IF OK (MIGHT BE UPPER)
	XCTR XW,[SETZM (AC2)]	; PUT A HALT THERE AT THE END OF THE BUFFER
	MOVEI AC3,10		; WE WILL LOOK IN THIS FAR FOR A CHANNEL SELECT
DDCWL:	XCTR XR,[MOVE AC2,(AC1)]; PICK UP WORD OF PROGRAM
	LDB TAC,[POINT 3,AC2,35]
	CAIN TAC,4		; IS IT A COMMAND WORD?
	JRST CHKAD		; YES, SEE IF IT HAS A CHANNEL SELECT IN IT
DDCINC:	ADDI AC1,1		; BUMP POINTER INTO USER CORE
	SOJG AC3,DDCWL		; BUMP COUNT OF DEPTH AND LOOP BACK
	HLRZ TAC,PRGNUM(DDB)	; NO CHANNEL SELECT, SEE IF WE CAN SEND TO HIS OWN SCREEN
	TRNN TAC,DISLIN!DMLIN
	JRST DDSCHN		; ON DD, OK, USE HIS MAIN CHANNEL
	JRST ILLCHN		; SORRY, YOU ARE NOT ON A DD

↑DDWAIT:
	SKIPN PRGCNT(DDB)
	POPJ P,			;NOTHING GOING ON
	MOVNI AC2,DIOWQ
	MOVEI AC3,400000
	CONO PI,APROFF
	SKIPN PRGCNT(DDB)
	JRST APRONJ		;MUST HAVE JUST FINISHED
	MOVEM AC2,JOBQUE(J)
	IORM AC3,PRGJMP(DDB)	;TELL PI ROUTINES TO WAKE US
	CONO PI,APRON
	SKIPGE JBTLIN(J)
	JRST WSCHED		;AVOID RETESTING IF DETACHED (HEADER WILL GO AWAY)
	PUSHJ P,WSCHED		;WAIT FOR IT
	JRST DDWAIT		;THEN CHECK AGAIN TO BE SURE

APRONJ:	CONO PI,APRON
	POPJ P,
;DDSCHN UPGQ0

; HERE WE ARE, READY TO SET THE CHANNEL ADDRESS OF HIS DATA DISC PROGRAM

DDSCHN:	MOVE	AC1,[CW 1,47,3,1,2,0]
	DPB	TAC,[POINT 8,AC1,23]
	MOVEM	AC1,PRGCW(DDB)		;PUT IN COMMAND WORD WITH CHANNEL SELECT
	XCTR	XR,[MOVE AC2,(UUO)]	;ADDRESS OF THE USER'S DPY PROGRAM
PRINTX HERE'S A JOB FOR THE MAPPIPLEXOR
	PUSHJ	P,CHKADR		;MAKE IT ABSOLUTE
	HRLI	AC2,DISJMP
	MOVSM	AC2,PRGJMP(DDB)		;PUT IN JUMP TO USER'S PROGRAM
	MOVEI	TAC,0
	XCTR	XR,[SKIPL (UUO)]	;OVERLAPPED MODE?
	JRST	UPGQ0			;NO
	XCTR	XRW,[MOVES 2(UUO)]	;BE SURE WE CAN WRITE HERE
	MOVEI	TAC,2(UUO)		;TAC←RELATIVE ADDRESS OF THE "RUN" FLAG
UPGQ0:	PUSHJ	P,GETQ
	XCTR	XR,[MOVE AC3,(UUO)]
	TLNN	AC3,200000		;DOUBLE FIELD MODE?
	JRST	UPGQ1			;NO
	XCTR	XR,[HRRZ AC2,3(UUO)]	;ADR OF WORD WITH LINE SELECT
	XCTR	XRW,[MOVES (AC2)]	;CHECK WRT ACCESS HERE
UPGQ1:
	NOCACHE	(CSHDD)
;	MTRON	(MTRSWP)
;	CONSZ	KLPAG,600000		;SKIP IF CACHE IS OFF
;	BLKO	CCA,			;CACHE IS ON.  VALIDATE CORE
;	CONSZ	APR,SWEEPB		;WAIT FOR SWEEP BUSY TO FALL.
;	JRST	.-1
;	MTROFF	(MTRSWP)

	TLNN	AC3,200000		;DOUBLE FIELD MODE?
	JRST	UPGQ2			;NO.
	HRLI	TAC,(AC2)		;RELATIVE ADDR OF THE LINE SELECT WORD
	PUSH	P,AC1
	PUSHJ	P,GETQ			;WILL NEED 2 Q BLKS
	SETOM	QFIELD(AC1)
	PUSHJ	P,UPGQ
	POP	P,AC1
UPGQ2:	SETZM	QFIELD(AC1)
	PUSHJ	P,UPGQ
	XCTR	XR,[SKIPL (UUO)]	;OVERLAPPED?
	JRST	DDWAIT			;NO - WAIT
	POPJ	P,			;YES - RETURN

UPGQ:	HRLM	DDB,(AC1)		;LOAD UP TASK BLOCK WITH PROGRAM HEADER
	MOVEI	AC2,POG			;DISPATCH TO USER PROGRAM SERVICE
	HRRM	AC2,(AC1)
	MOVEI	AC2,PRGCNT(DDB)		;PICK UP ADDRESS OF FAKE COUNT FIELD
	MOVEM	AC2,QCOUNT(AC1)
	MOVEM	TAC,QHPOS(AC1)		;STORE LINE SEL ADDR,,RUN FLAG ADDR
	TRNE	TAC,-1
	XCTR	XRW,[AOS (TAC)]		;COUNT USER'S FLAG - A TRANSFER IS RUNNING
	AOS	PRGCNT(DDB)		;AND FOR US
	MOVEM	J,QWAKE(AC1)
	MOVE	AC2,[XWD 1,50]		;ACT LIKE IT WILL TAKE ENTIRE SCREEN
	MOVEM	AC2,QLINE(AC1)
	AOS	JBTGLU(J)		;LOCK US IN CORE.
IFN FTSTAT,<PUSHJ P,GLUSTT>
	JRST	QBLK
;CHKAD CHKAC1 CHKAC2 CHKAC3 CHKAC4 CHKADR CHKADU

; GET HERE TO LOOK AT A USER'S COMMAND WORD AND SEE IF THERE IS A CHANNEL SELECT

CHKAD:	LDB TAC,[POINT 3,AC2,26]
	CAIN TAC,2		; IS IT A CHANNEL SELECT?
	JRST CHKAC1		; YES, SEE IF IT IS LEGAL.
	LDB TAC,[POINT 3,AC2,29]
	CAIN TAC,2
	JRST CHKAC2
	LDB TAC,[POINT 3,AC2,32]
	CAIN TAC,2
	JRST CHKAC3
	JRST DDCINC

CHKAC1:	LDB TAC,[POINT 8,AC2,7]
CHKAC4:	PUSHJ P,CHAD
	JRST DDSCHN

CHKAC2:	LDB TAC,[POINT 8,AC2,15]
	JRST CHKAC4

CHKAC3:	LDB TAC,[POINT 8,AC2,23]
	JRST CHKAC4

;CHECK & RELOC USER ADR
CHKADR:	HLRZ	AC3,JBTPAG(J)
	LSH	AC3,=9
	CAIG	AC3,(AC2)
	JRST	CHKADU		;PAST LOWER - TRY UPPER
	HRRZ	AC3,JBTPAG(J)
CHKADX:	LSH	AC3,=9
	ADD	AC2,AC3

IFN FTHPSG,<	TLNE	AC2,17	;CHECK TO MAKE SURE ADDRESS IS LOW ENOUGH.
		JRST	UUOERR	>

	POPJ	P,

CHKADU:	TRZN	AC2,400000	;SKIP IF UPPER SEGMENT ADDRESS.
	JRST	UUOERR		;CAN'T BE UPPER
	TRZE	AC3,400000	;SKIP UNLESS LOWER LARGER THAN 128K
	SUBI	AC2,1(AC3)	;SUBTRACT LOWER'S SIZE
	LDB	AC3,PSEGN
	JUMPE	AC3,UUOERR	;NO UPPER
	HLRZ	AC3,JBTPAG(AC3)
	LSH	AC3,=9
	CAIG	AC3,(AC2)
	JRST	UUOERR		;TOO BIG
	LDB	AC3,PSEGN
	HRRZ	AC3,JBTPAG(AC3)
	JRST	CHKADX
;CHAD MYCHN ILLCHN

;CHANNEL ADDRESS CHECKING. HE CAN WRITE ON HIS OWN SCREEN,
;OR ON ANY CHANNEL HE OWNS, OR ON ANY FREE CHANNEL.

CHAD:	JUMPE TAC,MYCHN		;GIVE HIM HIS OWN FOR 0
	ANDI TAC,37
	MOVEI AC1,(TAC)
	PUSHJ P,DDCHEK
	POPJ P,			;FREE
	JRST .+2
	POPJ P,			;HE OWNS IT
	MOVE AC1,JBTPRV(J)
	MOVE AC2,DDTAB(TAC)
	TLNN AC2,DDANYW		;MAYBE OWNER SAYS IT'S OK
	TLNE AC1,UPGPRV
	POPJ P,			;HE CAN WRITE ANYWHERE WITH THE PRIVILEGE
MYCHN:	HLRZ TAC,PRGNUM(DDB)	;GIVE HIM HIS OWN CHANNEL (IF ANY)
	TRNN TAC,DISLIN!DMLIN	;IS HE ON A DD?
	POPJ P,			;YES, OK
	SUB P,[1,,1]		;FLUSH RETURN FROM CHAD
ILLCHN:	MOVEI AC1,(DDB)
	SKIPE DPRLSF(DDB)
	PUSHJ P,FSGIVE		;MAKE SURE THE PHONY HEADER GETS RETURNED
	PUSHJ P,TTYFUW
	PUSHJ P,INLMES
	ASCIZ /ILLEGAL DD CHANNEL.
/
	JRST TYPGO
;PGSET PGSETA PGSET1 PGSET2 PGSL1

;;PGSET  SETS UP REQUESTED PIECE OF GLASS.

↑PGSET:	PUSHJ P,PRGFND		;FIND USER'S DPY PGM.
	POPJ P,			;NO DISPLAY HERE
	JUMPGE DDB,CPOPJ1	;JUMP UNLESS III
PGSETA:	HLRZ J,PGCALL(DDB)	;PTR. TO PG HEADER.
	JUMPE J,PGSET1		;IF NONE, START FROM SCRATCH.
	CAMLE UCHN,LSTPG(DDB)	;DOES THIS PG ALREADY "EXIST" ?
	JRST PGSET2		;NO. GO EXTEND THE HEADER.
	ADDI J,(UCHN)		;YES. MAKE J POINT AT
	JRST CPOPJ1		;THE CALLING INSTR. FOR IT.
PGSET1:	PUSHJ P,CGETFS		;GET BLOCK TO USE FOR PG HEADER.
	MOVEM AC1,J
	SETOM LSTPG(DDB)	;NO PG'S EXIST YET.
	HRLI TAC1,PGCALL+1(DDB)	;INVENT RETURN JMP TO PGM HEADER.
	HRRI TAC1,DISJMP
	MOVEM TAC1,(J)		;PUT IN FIRST WORD OF PG HEADER.
	HRLI J,DISJMP
	MOVSM J,PGCALL(DDB)	;FIX CALL ON PG HEADER.
PGSET2:	MOVEI TAC1,DISNOP	;EXTEND ACTIVE PART OF PG HEADER.
	ADD J,LSTPG(DDB)	;GET LAST CURRENT PAGE.
	EXCH UCHN,LSTPG(DDB)
	SUB UCHN,LSTPG(DDB)	;NO. OF PLACES TO EXTEND.
	HRLI J,(UCHN)		;MAKE AOBJN WORD.
	MOVE UCHN,1(J)		;GET RETURN JMP.
PGSL1:	MOVEM UCHN,2(J)		;PUT RTN JMP FARTHER UP.
	MOVEM TAC1,1(J)		;PUT NOP WHERE IT USED TO BE.
	SETZM SIZE+1(J)		;THIS PG IS NOW 0 SIZE.
	AOBJN J,PGSL1
	JRST CPOPJ1
;DPYERR DPYER1

; THIS IS THE DPY ERROR ROUTINE. IT TYPES OUT THE PC IN TAC1 ON
; THE DISPLAY.

DPYERR:	PUSH P,TEM
	PUSH P,TAC1
	JSA J,ERRP		;DO THIS SO NO TERMINATING CRLF
	POINT 7,[ASCIZ/$$ USER DPY ERROR AT /]
	HRR AC1,(P)
	MOVEI AC2,6
DPYER1:	HRRZS AC1
	LSH AC1,3		;GET ONE OCTAL DIGIT.
	TLO AC1,60
	LDB CHR,[POINT 7,AC1,17]
	PUSH P,AC1		; SAVE ALL OUR RELEVANT DATA
	PUSH P,AC2
	MOVE DAT,CURPP(DDB)	; PICK UP PAGE PRINTER CONTROL BLOCK ADDRESS
	HLL DAT,DDB		; PUT IN BIT INDICATING TYPE OF DISPLAY
	OFFSCN			;TURN OFF SCANNER CHANNEL
	PUSHJ P,DTYO		;PRINT A DIGIT
	ONSCN			;TURN ON SCANNER CHANNEL
	POP P,AC2
	POP P,AC1
	SOJG AC2,DPYER1
	ERMS {}
	POP P,TAC1
	POP P,TEM
	POPJ P,
;UPGMVM UPGMOV UPGMV

↑↑UPGMVM:PUSHJ P,UPGMV		;DO `MOVEM' INTO P OF G: TAKE CARE OF PRELIMINARIES.
	POPJ P,			;IGNORE IF NO CAN DO
	TRNN 3			;IF THING BEING STORED IS A COMPLICATED DPY INSTR.,
	PUSHJ P,SPECOP		; THEN CHECK AND RELOCATE IT.
	MOVSS DAT		;GET RELOCATED ADDRESS OF THE UPGMVM.
	MOVEM (DAT)		;DO THE STORE.
	POPJ P,

↑↑UPGMOV:PUSH P,UCHN		;DO A `MOVE' FROM THE CURRENT P OF G.
	PUSHJ P,UPGMV		;LET SOMEBODY ELSE DO THE REAL WORK !
	TDZA DAT,DAT		;RETURN 0 IF NO CAN DO
	JRA DAT,.+1		;HO, HO, HO.  SEE THE CLEVER PROGRAMMER.
	POP P,UCHN		; P1ULOC DOESN'T HAVE OUR UUO ANY MORE, MUST SAVE CHANNEL NUMBER OURSELVES
	XCTR XW,[MOVEM DAT,(UCHN)]	;PUT RESULT IN USER'S AC.
	POPJ P,

UPGMV:	PUSHJ P,PRGFND		;COMMON ROUTINE FOR UPGMOV AND UPGMVM. FIND PRGM.
	POPJ P,			;NO DPY, NO MOVY
	JUMPGE DDB,CPOPJ	;NO III, NO NOTHING
	SKIPE J,CURPG(DDB)	;GET CURRENTLY SELECTED P OF G.
	SKIPN SIZE(J)		;MAKE SURE IT EXISTS.
	POPJ P,
	XCTR XR,[MOVE DAT,(UCHN)]	;PICK UP CONTENTS OF USER'S AC.
	MOVS T2,(J)		;GET PTR. TO THE P OF G.
	SUBI T2,PGNP		;MAKE IT POINT TO THE DESCRIPTOR WORDS.
	HRLZ TEM,PGSA(T2)	;STARTING ADDR. (IN USER CORE) OF P OF G.
	HRLZ UCHN,PGWC(T2)	;LENGTH OF P OF G.
	HRLZ UUO		;ADDRESS OF THE `MOVE' OR `MOVEM'.
	MOVE UUO,[XWD TAC,TBL]	;PREPARE TO GENERATE A BLOCK MAP FOR
	HRLZM T2,(UUO)		;THE P OF G. (PUT IN BOTTOM PTR.).
	SKIPE T2,LINK(T2)	;GET NEXT BLOCK, IF ANY.
	AOJA UUO,.-2		;PUT IT IN MAP.
	HRRI UUO,TBL		;MAKE UUO POINT TO MAP.
	HLRZ TAC1,0		;PRINT THIS ADDRESS IN EVENT OF ERROR!
	PUSHJ P,ADROP		;NOW RELOCATE AND CHECK ADDR. OF MOVE.
	EXCH DAT,0		;PUT OPERAND (IF `MOVEM') INTO 0.
	JRST CPOPJ1
;PGIOT PGSEL VPGACT PGACT PGACL PGAC1 PGCLR PGCLR1

↑↑PGIOT:
	CAIL UCHN,PGMAX		;GENERAL P OF G SERVICE IOT.
	JRST UUOERR
	PUSHJ P,DDFND		; FIND A PROGRAM HEADER (UCHN =3 GUARANTEES ONE)
	POPJ P,			;IGNORE IF NO DISPLAY
	JUMPL DDB,@PGDSP(UCHN)	; IF III, DISPATCH NOW
	CAIGE UCHN,3		; ONLY ONES LEGAL FOR DD CURRENTLY
	POPJ P,			; ALL THE OTHERS DON'T MAKE SENSE.
	JRST @PGDSP(UCHN)

DEFINE UUOS{FOR X IN(PGSEL,PGACT,PGCLR,DDUPG,PGINFO)}

PSHSYS
LOSYS

UUOMAC PGDSP,PGIOT
PGMAX←←UUOCNT

POPSYS

PGSEL:	HRRZ UCHN,UUO		;SELECT THE P OF G INDICATED BY THE ADDR. FIELD.
	CAIL UCHN,20		;IS IT LEGAL ?
	JRST ADRERR
	PUSHJ P,PGSETA		;FIND THE P OF G.
	POPJ P,			;SHOULD NEVER GET HERE, BUT PGSETA SKIP RETURNS
	MOVEM J,CURPG(DDB)	;MAKE IT THE CURRENTLY P¬lECTED ONE.
	POPJ P,

↑↑VPGACT:MOVEI DDB,(DAT)	;HERE ON CLK RQ FROM VDSTR
	HLRZ UUO,PRGACT(DDB)	;THIS MAKES THE PROGRAM AGREE WITH THE BITS
PGACT:	HLRZ J,PGCALL(DDB)
	JUMPE J,CPOPJ
	HRLM UUO,PRGACT(DDB)
	MOVE TAC,LSTPG(DDB)
	MOVEI AC1,DISNOP
	MOVEI AC2,DISJSR
PGACL:	SKIPN SIZE(J)
	JRST PGAC1
	HRRM AC1,(J)
	TRNE UUO,400000
	HRRM AC2,(J)
PGAC1:	ROT UUO,1
	SOJL TAC,CPOPJ
	AOJA J,PGACL

;;PGCLR FLUSHES ANY PIECES OF GLASS A LOSER MAY HAVE.  DDB SHOULD BE SET UP POINTING TO PRGM HEADER.

↑PGCLR:	SETZM CURPG(DDB)
	HLRZ J,PGCALL(DDB)	;GET PTR. TO PG HEADER BLK.
	JUMPE J,CPOPJ		;IF NONE, GO AWAY.
PGCLR1:	MOVEI TAC1,DISNOP	;FREE A PIECE OF GLASS.
	PUSHJ P,UPREL1		;(SEE ABOVE.)
	SOSL LSTPG(DDB)		;HAVE WE GOT ALL THE PG'S ?
	AOJA J,PGCLR1		;NO. GET SOME MORE.
	MOVEI UCHN,DISNOP	;TURN OFF CALL ON THE PG HEADER.
	EXCH UCHN,PGCALL(DDB)
	HLRZ AC1,UCHN		;PTR. TO HEADER.
	JRST CGIVFS		;FREE THE PG HEADER BLOCK.
;PGINFO PGCLP PGSZ PGCNT PGXLP

; THIS UUO GETS INFORMATION FROM THE SYSTEM ABOUT THE USER'S PIECES
; OF GLASS. IT IS GIVEN IN A 17. WORD TABLE. THE FIRST WORD IS
; XWD <POG ACTIVE BITS>,<PP ACTIVE BITS> IN PPACT AND PGACT FORMAT.
; THE NEXT 16. WORDS, ONE WORD FOR EACH POG, IS XWD <WORD COUNT>,<STARTING ADDRESS>

PGINFO:	MOVE AC1,PRGACT(DDB)	; PICK UP THE ACTIVATION BITS
	XCTR XW,[MOVEM AC1,(UUO)]
	ADDI UUO,1
	HLRZ AC1,PGCALL(DDB)	; PICK UP ADDRESS OF UPG CONTROL BLOCK
	SETZ AC3,
	JUMPE AC1,PGXLP		; JUMP IF NO POGs IN USE -- ME 5/26/75
PGCLP:	HLRZ CHR,(AC1)		; PICK UP ADDRESS OF FIRST BLOCK OF CODE
	JUMPE CHR,PGSZ		; IF NOTHING THERE, CLEAR WORD IN TABLE
	SUBI CHR,PGNP		; POINT US TO THE CONTROL INFORMATION
	HRRZ AC2,PGSA(CHR)	; PICK UP THE STARTING ADDRESS
	XCTR XRW,[HRRM AC2,(UUO)]
	HRRZ AC1,PGWC(CHR)	; AND THE WORD COUNT
	XCTR XRW,[HRLM AC1,(UUO)]
	JRST PGCNT

PGSZ:	XCTR XW,[SETZM (UUO)]
PGCNT:	ADDI UUO,1		; BUMP POINTER INTO USER'S TABLE
	ADDI AC1,1		; AND POINTER TO UPG CONTROL BLOCK
	ADDI AC3,1		; AND COUNT OF NUMBER OF POGS SEEN
	CAMG AC3,LSTPG(DDB)	; ARE WE PAST THE LAST?
	JRST PGCLP		; NO, LOOP BACK
PGXLP:	CAILE AC3,17		; ARE WE DONE?
	POPJ P,			; YES, LEAVE
	XCTR XW,[SETZM (UUO)]
	ADDI AC3,1		; AND COUNT
	AOJA UUO,PGXLP		; BUMP POINTER AND LOOP

BEND UPG
;DPYTY1 DPYERT DPYTYP DPYTY4 DPYTY5 DPYTY2 DPYTY6 DPYTY3

;;DPYTYP IS CALLED AT CLOCK LEVEL TO TYPE SOME CHRS. FROM A 
;; TTY OUTPUT BUFFER ONTO A DISPLAY.  DAT CONTAINS LINE NUMBER.

DPYTY1:	MOVSI TAC1,DISLIN!DDDLIN!DMDLIN
	TRNN DAT,-1⊗PUNITS	; LEGAL LINE NUMBER?
	TDNN TAC1,LINTAB(DAT)	; YES, BUT IS IT A DISPLAY?
	JRST DPYTER		; NO, GIVE ERROR MESSAGE
	SKIPN DDB,TTYTAB(DAT)	; PICK UP DEVICE DATA BLOCK ADDRESS
	POPJ P,			; IF NONE, LEAVE NOW, NO CHARACTERS TO TYPE
	HRRZ TAC1,DAT		; SAVE LINE NUMBER
↑DPYERT:
	HRRI DAT,TTIBUF(DDB)	; PICK UP INPUT BUFFER ADDRESS
	HRLI DAT,DPYTY1		; MAKE US COME BACK TO THIS ROUTINE IF WE HAVE TO WAIT
	JRST DPYTY4

↑DPYTYP: HGMAC(34)
	MOVSI TAC1,DISLIN!DDDLIN!DMDLIN
	TRNN DAT,-1⊗PUNITS	; LEGAL LINE NUMBER?
	TDNN TAC1,LINTAB(DAT)	; YES, BUT IS IT A DISPLAY?
	JRST DPYTER		; NO, GIVE ERROR MESSAGE
	HRLI DAT,DPYTYP		; COME BACK TO HERE IF WE HAVE TO WAIT
	SKIPN DDB,TTYTAB(DAT)	; IS THERE A DDB THERE?
	POPJ P,			; NO, NOT MUCH TO DO NOW!
	HRRZ TAC1,DAT		; SAVE LINE NUMBER
	HRRI DAT,TTOBUF(DDB)	; PICK UP OUTPUT BUFFER ADDRESS
DPYTY4:	MOVEI DSER,(DDB)	;PRESERVE A COPY OF DDB ADDR.
	HRRZ DDB,LETAB(TAC1)	;FIND DPY FOR THIS JOB.
	JUMPN DDB,DPYTY2	; IF WE HAVE A BLOCK, OK
DPYTY5:	PUSHJ P,DPYMAKE		; OTHERWISE, TRY TO MAKE ONE
	JRST DPYTLN		; NO ONE HOME, LOSE LOSE (PLANT CLOCK REQ FOR LATER)
	AOS NDPMAK#		; BUMP NUMBER OF TIMES WE HAD TO DO THIS
	HRRZ DDB,LETAB(TAC1)	; GET POINTER TO HEADER WE JUST MADE
DPYTY2:	MOVNI IOS,12		;TYPE NO MORE THAN 12 CHARS/TICK ON III
	SKIPE UUO,CURPP(DDB)	;TYPE ON CURRENTLY SELECTED P OF P.
	JRST DPYTL1
DPYTY6:	PUSH P,DAT		; SAVE THE OUTPUT BUFFER ADDRESS
	HLRE TAC,PRGNUM(DDB)	; PICK UP DD CHAN OR DISPLAY-TYPE BIT
	PUSHJ P,PPINIT		; SEE IF WE CAN GET A PAGE PRINTER
	JRST DPYTY3		; NO, COME BACK NEXT TICK AND TRY AGAIN
	PUSHJ P,PPSET		; YES, INITIALIZE IT
	HRRZ UUO,CURPP(DDB)	; PICK UP ADDRESS OF PAGE PRINTER CONTROL BLOCK
	POP P,DAT		; GET BACK TTY OUTPUT BUFFER ADDRESS
	JRST DPYTL1

DPYTY3:	POP P,DAT
	JRST DPYTLN		;PLANT CLOCK REQ. FOR LATER.
;DPYTL1 DPYTL2 DPTL2A DPTL2B DPYTL3 DPYTL4

; HERE AT CLOCK LEVEL WITH DAT SET TO
; THE TTY BUFFER AND UUO POINTING TO THE PAGE PRINTER CONTROL BLOCK

DPYTL1:	HLL UUO,PPDPY(UUO)	; GET BITS INDICATING DISPLAY TYPE
	SKIPE DPHOLD(DDB)	; ARE WE IN HOLD MODE?
	JRST STAR		; YES, PRINT STARS AND GO AWAY
	SKIPE PPENQ(UUO)	; DO WE CURRENTLY HAVE ANYTHING IN THE QUEUE?
	JRST DPYTLN		; YES, PLANT CLOCK REQ. TO COME BACK NEXT TICK.
				;   (FOR SOME REASON, REFLIX ZEROS QWAKE)
IFN FTDM,<
	SETZ AC1,		;No DM output queued yet
	TLNE UUO,DMLIN
	PUSHJ P,DMNOHD		;Force out any previously set up glitches now.
>;FTDM
DPYTL2:	OFFSCN			;AVOID EMBARASSING CONFUSION OVER EMPTY BUFFER
DPTL2A:	PUSHJ P,GETCHO		; GET A CHARACTER
	JUMPE CHR,DPYTLX	; BUFFER EMPTY

	SKIPL	LSTCHR(UUO)	;REG 1/25/74 DID DTYO INVENT CRLF LAST TIME?
	JRST	DPTL2B		;NO. BEHAVE NORMALLY
	CAIN	CHR,15		;YES. CR'S GET FLUSHED NOW.
	JRST	DPTL2A		;
	MOVEM	CHR,LSTCHR(UUO)	;SAVE CHR
	MOVEI	CHR,12
	EXCH	CHR,LSTCHR(UUO)	;RESTORE CHR. LSTCHR NOW LOOKS LIKE NORMAL LF.
	CAIN	CHR,12		;FIRST LF AFTER LSTCHR WAS SET TO -1 IS FLUSHED.
	JRST	DPTL2A		;ONLY IF NO PREVIOUS CHARACTER (EXCEPT CR) SEEN

DPTL2B:	PUSH P,CHR		; SAVE THE CHARACTER
	EXCH DAT,UUO		; GET PP CONTROL BLOCK ADDRESS IN DAT
	PUSHJ P,DTYO		; SEND THE CHARACTER OUT
	ONSCN			;TURN ON SCANNER CHANNEL
	EXCH DAT,UUO
	POP P,CHR

	SKIPGE LSTCHR(UUO)	;DID DTYO INVENT CRLF AT LONG LINE?  REG 1/25/74
	MOVEI CHR,12		;YES. PRETEND WE WERE THE ONE WHO ASKED FOR LF.

	CAIN CHR,12		; IS IT END OF LINE TIME?
	SOSE LHCNT(DDB)		; YES, ARE WE SUPPOSED TO HOLD NOW?
	JRST DPYTL3		; NO, GO ON
	LDB AC1,HLINES		; YES, RESET HOLD COUNT
	MOVEM AC1,LHCNT(DDB)
;	SETOM DPHOLD(DDB)
	JRST STAR0

DPYTL3:	SKIPE GLTCH(UUO)	; GLITCH TIME?
	SKIPE GLHCNT(DDB)	; YES, IS IT TIME TO HOLD?
	JRST DPYTL4
	LDB AC1,HGLTCH		; YES, RESET COUNT
	MOVEM AC1,GLHCNT(DDB)
;	SETOM DPHOLD(DDB)
	JRST STAR0

DPYTL4:	JUMPGE UUO,DPTDD	; IF DD OR DM, GO TO SPECIAL ROUTINE
;*** RPH PATCH TO SLOW DOWN OUTPUT OF BLANK LINES
	CAIE CHR,12
	CAIN CHR,15
	JRST DPYTLN
;*** END SLOW DOWN PATCH
	AOJN IOS,DPYTL2		; OTHERWISE, COUNT DOWN AND LOOP BACK
	JRST DPYTLN		; AND PUT IN ANOTHER CLOCK REQUEST IF TOO MANY CHARACTERS THIS TICK
;DPYTER STAR IISTAR DMSTAR DMSTA2 STAR0 STAR1

; ROUTINE TO TYPE CTY ERROR MESSAGE ON ILLEGAL LINE NUMBER

DPYTER:	PUSH P,DAT
	PUSHJ P,DISERR
	[ASCIZ /ILLEGAL LINE NUMBER AT DPYTYP - /]
	DISARG OCT,<-1(P)>
	[ASCIZ /
/]
	-1
	POP P,DAT
	POPJ P,

; ROUTINE TO TYPE STAR ON LINE THREE WHEN TYPEOUT IS HELD UP

STAR0:
IFN FTDM,<
	HRRZ AC1,TPJMP(UUO)	; FIRST, IS THE P OF P INACTIVE?
	CAIE AC1,DISNOP
	TLNN UUO,DMLIN		;Or is it not a DM?
	JRST STAR1		;Yes, hold now
	HLLOS DPHOLD(DDB)	;Tell QDMR to hold after queueing current xfers
	JRST QDMR
>;FTDM

STAR1:	SETOM DPHOLD(DDB)
STAR:	JUMPL UUO,IISTAR	; SEPARATE ROUTINE FOR III
	TLNN UUO,DDDLIN
	JRST DMSTAR		; ALSO DIFFERENT ROUTINE FOR DM
	PUSHJ P,GETQ		; GET A TASK BLOCK
	PUSH P,AC1		; SAVE ITS ADDRESS
	PUSHJ P,GETQ		; PICK UP ONE FOR THE OTHER FIELD
	MOVE AC2,(P)		; GET THE ADDRESS OF THE FIRST ONE BACK
	HRLI UUO,PPSTAR		; SET UP DISPATCH TO ROUTINE THAT DRAWS STAR ON LINE THREE
	MOVSM UUO,(AC1)		; SET IT IN FIRST TASK BLOCK
	MOVSM UUO,(AC2)		; AND IN SECOND ONE
	SETZM QCOUNT(AC1)	; DON'T WAKE ANYBODY UP ABOUT THIS
	SETZM QCOUNT(AC2)
	SETZM QFIELD(AC1)	; FIRST FIELD OF ERASURE
	SETOM QFIELD(AC2)	; SECOND FIELD
	MOVE AC3,[XWD 3,3]	; TELL QBLOCK WHERE TO QUEUE THIS REQUEST
	MOVEM AC3,QLINE(AC1)
	MOVEM AC3,QLINE(AC2)
	PUSHJ P,QBLOCK		; NOW QUEUE UP THE REQUESTS
	POP P,AC1
	JRST QBLOCK

IISTAR:	MOVE AC1,PSELB(DDB)	; PICK UP GUY'S SELECT WORD
	AND AC1,[77B5]		; MASK OUT ALL BUT HIS SELECT BIT
	ORM AC1,DPYHLD		; SELECT HIM FOR THE MASSAGE
	LSH AC1,-=12		; MOVE OVER TO DESELECT FIELD
	ANDCAM AC1,DPYHLD
	POPJ P,

DMSTAR:
IFE FTDM,<
	PUSHJ P,NODMDP		; CAN'T GET HERE YET I THINK (HOPE)!
	JRST 4,AUTOLOAD
>;
IFN FTDM,<
	PUSH P,[440700,,DMSTR]	;Byte pointer to holding message.
DMSTA2:	PUSHJ P,GETQ
	MOVEI AC2,NOEEOL	;Avoid erasing whole line 
	HRRM AC2,QFLAGS(AC1)
	HRLM DDB,QFLAGS(AC1)
	MOVEI AC2,2		;Third line, first column
	MOVEM AC2,QXY(AC1)
	MOVEI AC2,LDMSTR*5	;Number of characters in holding message.
	MOVEM AC2,QDMCNT(AC1)
	SETZM QCOUNT(AC1)	;Don't wake anyone up
	POP P,QTAKR(AC1)
	MOVEI AC2,DMSPPT-QLINK(DDB)	;Queue this xfer in special queue
	PUSHJ P,QDM
	MOVEI DAT,(DDB)		;Dpy header
	JRST STRTDM		;Make sure he see this message
>;FTDM
;UNHOLD UNHIII UNHDM

; ROUTINE, CALLED FROM CLOCK CALL WITH LINE NUMBER IN DAT, TO CONTINUE PAGE PRINTER

↑UNHOLD:
	HRLI DAT,DPYTYP		; SET UP TO COME BACK TO PRINT ROUTINE IF DONE
	MOVSI TAC1,DISLIN!DDDLIN!DMDLIN
	TRNN DAT,-1⊗PUNITS	; IS THE LINE NUMBER LEGAL?
	TDNN TAC1,LINTAB(DAT)	; YES, BUT IS IT A DISPLAY?
	JRST DPYTER		; NO, TYPE ERROR MESSAGE
	SKIPN DDB,TTYTAB(DAT)	; IS THERE A TTY DDB?
	POPJ P,			; NO, FORGET IT.
	HRRZ TAC1,DAT		; SAVE LINE NUMBER
	HRRI DAT,TTOBUF(DDB)	; PICK UP OUTPUT BUFFER ADDRESS
	MOVEI DSER,(DDB)	; COPY THE DEVICE DATA BLOCK POINTER
	HRRZ DDB,LETAB(TAC1)	; GET DPY HEADER
	JUMPE DDB,DPYTY4	; IF NO PROGRAM HEADER, NO STAR TO ERASE
	SKIPN UUO,CURPP(DDB)	; GET ADDRESS OF PAGE PRINTER CONTROL BLOCK
	JRST DPYTY6		; IF NONE, GO MAKE ONE UP
	HLL DDB,PPDPY(UUO)	; GET BITS TO DISTINGUISH TYPES OF DISPLAYS
	HLL UUO,DDB
	JUMPL UUO,UNHIII
	TLNE UUO,DMLIN
	JRST UNHDM		; DATAMEDIA DISPLAY
	PUSHJ P,GETQ		; GET A TASK BLOCK
	PUSH P,AC1		; SAVE ITS ADDRESS
	PUSHJ P,GETQ		; GET ANOTHER ONE FOR THE OTHER FIELD
	MOVE AC2,(P)		; PICK UP ADDRESS OF FIRST ONE
	SETZM QFIELD(AC1)	; SEND IT OUT ON ONE FIELD
	SETOM QFIELD(AC2)	; THE OTHER ON THE OTHER
	HRLI UUO,ERASE		; DISPATCH TO THE ERASURE ROUTINE
	MOVSM UUO,(AC1)		; SET THAT IN DISPATCH ADDRESS
	MOVSM UUO,(AC2)
	SETZM QCOUNT(AC1)	; DON'T WAKE ANYBODY UP
	SETZM QCOUNT(AC2)
	MOVE AC3,[XWD 3,3]	; ERASE LINE 3
	MOVEM AC3,QLINE(AC1)
	MOVEM AC3,QLINE(AC2)
	PUSHJ P,QBLOCK
	POP P,AC1
	PUSHJ P,QBLOCK
	JRST DPYTL1

UNHIII:	MOVE AC1,PSELB(DDB)
	AND AC1,[77B5]
	ANDCAM AC1,DPYHLD
	LSH AC1,-=12
	ORM AC1,DPYHLD
	JRST DPYTL1

UNHDM:
IFE FTDM,<
	PUSHJ P,NODMDP		; CAN'T GET HERE YET I THINK (HOPE)!
	JRST 4,AUTOLOAD
>;¬FTDM
IFN FTDM,<
	PUSHJ P,DPYTLN		;Plant request for DPYTYP to start typeout again
	PUSH P,[440700,,DMCLR]	;Byte pointer to text to clear holding msg
	JRST DMSTA2
>;FTDM
;DPTDD DPTDDK DPYTLN DPYTIM

; COME HERE FOR DATA DISK TO SEE IF IT IS END OF LINE OR GLITCH TIME.

DPTDD:	TLNN UUO,DMLIN		; DON'T STOP DM JUST BECAUSE OF END OF LINE
	CAIE CHR,12		; IS THIS END OF DD LINE?
	SKIPE GLTCH(UUO)	; OR HAS THE PAGE PRINTER GLITCHED ON DD OR DM?
	JRST DPTDDK		; YES, QUEUE UP A REQUEST AND LEAVE
	JRST DPYTL2		; OTHERWISE, PUT IN ANOTHER CHARACTER

DPTDDK:	HRRZ AC1,TPJMP(UUO)	; FIRST, IS THE P OF P ACTIVE?
	CAIN AC1,DISNOP
	JRST DPYTL2		; NO, JUST EMPTY THE BUFFER
	TLNN UUO,DMLIN
	JRST QDDR		; DATA DISC
	JRST QDMR		; DATAMEDIA

↑DPYTLN:HRR DAT,TAC1		; PUT IN LINE NUMBER AS DATUM
↑DPYTIM:CONO PI,PIOFF
	IDPB DAT,CLKQ		;PUT IN CLOCK REQUEST.
	CONO PI,PION
	POPJ P,
;QDMR QDMR2 DMNXBK DMNONX DMNON2 DMNON3 DMNON4 DMNON5 DMNOQB DMQGLC DMPPST DMNOHD GLTCHX DMSTHD DMSHFT GLTCHZ CHASPP

;Here at clock level with ch 5 on.
;Perhaps it should be off for at least some critical section.
;LH DAT has routine to wakeup (LERELE or DPYTYP).
;RH TAC1 has data for that routine (dpy hdr or line nbr)
;DDB has dpy header, UUO has PP control block address.
;DDB, UUO, and DAT are all preserved.
;TAC1 is clobbered by STRTDM, but only to line.bits,,line.number
QDMR:
IFE FTDM,<
	PUSHJ P,NODMDP		; CAN'T GET HERE YET I CLAIM! --ME
	JRST 4,AUTOLOAD
>;¬FTDM
IFN FTDM,<

	SETZM GLTCH(UUO)	;We'll put out any needed glitches now
	SKIPE TAC,DMLAST(UUO)	;Get byte pointer to first char to be output
	JRST QDMR2
	PUSHJ P,CHASPP		;Flush any queued PP text xfers since we redraw all
	EXCH DAT,UUO		;POSLIN and GLNADR want PP pointer in DAT
	PUSHJ P,POSLIN		;Get number of first line of PP
	JUMPG AC3,.+2
	MOVEI AC3,1		;PP above screen, start at top of screen
	MOVEM AC3,DMPPXY(DAT)	;Set up cursor position for output (LH≡X=0)
	OFFSCN			;Don't let LE glitch us while we thinking
	PUSHJ P,GLNADR		;Get address of text of first line
	EXCH DAT,UUO
	SETZM DMGLCH(UUO)	;No glitches needed now
	SOS AC3,DMPPXY(UUO)	;Normalize cursor position for DM
	CAML AC3,DPYHGT(DDB)	;PP start below screen?
	JRST SCNONJ		;Yes, flush xfer
	HRLI AC2,440700
	AOS TAC,AC2		;It was really address of LF ending previous line
	MOVEM TAC,DMLAST(UUO)
	ONSCN
QDMR2:	SETZ AC1,		;No queue block ready yet
	MOVEI AC3,1
	TDNE AC3,(TAC)		;Is first word text? (Not if virgin PP)
	CAMN TAC,PPTR1(UUO)	;Have we caught up with Page Printer PUTR?
	JRST DMNOQB		;Better be true that LH(PPTR1) is never 440700!
	LDB AC2,[360600,,TAC]	;Get position field of byte ptr
	IDIVI AC2,7		;Number of bytes to be output from current word
	OFFSCN			;Don't let LE call DTYO while we examine buffer
	TDNE AC3,1(TAC)
	AOJA TAC,.-1		;Count number of ASCID words following
PRINTX QDMR should check for reaching bottom of screen here in PP xfer.
	MOVE AC3,TAC
	SUB AC3,DMLAST(UUO)	;Number of full words
	IMULI AC3,5		;Number of bytes
	ADD AC2,AC3		;Total bytes to be output in this block
	JUMPE AC2,DMNXBK	;None, skip to next PP text block
	PUSHJ P,GETQ		;Get block for a queue entry
	MOVEM AC2,QDMCNT(AC1)	;Store output byte count
;We later subtract from QDMCNT the number of nulls in bytes at end of the block.
	MOVE AC2,DMLAST(UUO)
	MOVEM AC2,QTAKR(AC1)	;And output byte pointer
	MOVEI AC2,DMATXY!CHASTE!QUO177	;Interpret 177s as normal char,
	MOVEM AC2,QFLAGS(AC1)	; erase old line, and update DMPPXY
	MOVEI AC2,DMPPXY(UUO)
	MOVEM AC2,QXYLOC(AC1)	;Pass address of word containing cursor position
	SETZM PPVIRG(UUO)	;No longer virgin PP
DMNXBK:	MOVEI AC3,1
	HRRZ AC2,1(TAC)		;Get dpy word that had low-order bit off
	CAIE AC2,DISJMP		;Is this a display jump instruction?
	JRST DMNONX		;No, end of text
	HLRZ AC2,1(TAC)		;Get destination address of jump
	TDNN AC3,(AC2)		;Is this a text word?
	JRST DMNONX		;No
	ONSCN
	MOVEI TAC,(AC2)
	HRLI TAC,440700
	MOVEM TAC,DMLAST(UUO)	;Set up initial byte pointer
	JUMPE AC1,QDMR2		;Got a xfer ready?
	PUSHJ P,QDMPP		;Yes, queue it in PP queue
	JRST QDMR2		;Now queue up xfer for next block

DMNONX:	MOVE AC2,PPTR1(UUO)
	MOVEM AC2,DMLAST(UUO)	;Save pointer to last text char queued
	JUMPE AC1,DMNON7	;Jump if no queue entry byte count to fix
	MOVEI AC2,0		;Count null bytes to flush
DMNON3:	CAME AC3,(TAC)		;Is this word full of nulls?
	JRST DMNON2
	SUBI AC2,5		;Yes, count 5 nulls to uncount
	SOJA TAC,DMNON3

DMNON2:	SKIPE AC3,(TAC)		;Get last word of text to count its nulls
DMNON4:	TRNE AC3,376
	JRST DMNON5
	LSH AC3,-7
	SOJA AC2,DMNON4

DMNON5:	ADDM AC2,QDMCNT(AC1)	;Uncount the nulls
	MOVE AC3,DPHPOS(UUO)
	ADD AC3,LNLNGT(UUO)	;See what horiz. position is.
	JUMPE AC3,DMNON6	;Ok if at left margin
	MOVE AC2,LSTCHR(UUO)
	CAIE AC2,12
	JRST DMNON6
	MOVSI AC2,70000		;Here we are with bare LF to account for
	ADDM AC2,DMLAST(UUO)	;Back up so next time we send CR that overwrites LF
	MOVEI AC2,DMXUSR	;Have routine to run after this xfer
	IORM AC2,QFLAGS(AC1)
	HRLOI AC2,GLTCHZ	;Back up DMPPXY one line when done
	MOVEM AC2,QFREE(AC1)
DMNON6:	PUSHJ P,QDMPP		;Now queue final text xfer
DMNON7:	ONSCN
DMNOQB:	SKIPG DPHOLD(DDB)	;Time to hold after these xfers?
	JRST DMNOHD		;No
	PUSHJ P,GETQ		;Yes, enter a null xfer request to set DPHOLD
	SETZM DPHOLD(DDB)	;But don't hold yet
	MOVEI AC2,DMXUSR!QUO177	;QUO177 allows CHASPP to flush this xfer
	MOVEM AC2,QFLAGS(AC1)
	MOVEI AC2,DPHOLD(DDB)
	HRLI AC2,DMSTHD		;Routine to set DPHOLD
	MOVEM AC2,QFREE(AC1)
	SETZM QDMCNT(AC1)	;No chars to xfer
	PUSHJ P,QDMPP		;Queue this null request in PP queue
DMNOHD:	SKIPG AC2,DMGLCH(UUO)	;Any glitches to force out now?
	JRST DMPPST		;No
	CAMG AC2,PGSIZ(UUO)	;Want to glitch more than whole PP size?
	JRST DMQGLC		;No
	PUSHJ P,CHASPP		;Yes, flush all PP text xfers
;Since we're glitching whole PP, would be faster and better to just erase whole PP,
;but for now we'll do it the easy way
	MOVE AC2,PGSIZ(UUO)	;Glitch whole PP
	MOVEM AC2,DMGLCH(UUO)
	SETZM DMLAST(UUO)	;And force out whole PP next time
DMQGLC:	MOVN AC3,DEL(UUO)	;Move screen text up by number of lines per glitch
;PPYPOS enters here to shift screen
DMSHFT:	PUSH P,AC3		;Save number of lines to move by
	EXCH DAT,UUO
	PUSHJ P,POSLIN		;Get number of first line of PP
	EXCH DAT,UUO
	SUBI AC3,1		;Normalize it for DM
	MOVE TAC,PGSIZ(UUO)	;Number of glitches in PP
	IMUL TAC,DEL(UUO)	; * size of each glitch = number of lines in PP
	ADD TAC,AC3		; + line before first = last line of PP
	JUMPL TAC,DMQGL2	;Jump if whole xfer is above screen
	SKIPL AC2,(P)
	SUB AC3,AC2		;Moving down, do it from above new 1st line of PP
;Flushing next two instructions will flush "25th line" when it comes up.
	CAML TAC,DPYHGT(DDB)
	JRST DMSHF4
	SKIPG AC2,(P)
	ADD TAC,AC2
DMSHF4:	CAML AC3,DPYHGT(DDB)	; or if whole xfer is below screen
	JRST DMQGL2
	JUMPGE AC3,DMSHF3	;Jump unless xfer starts above screen
	SETZ AC3,		;Start from top of screen
DMSHF3:	PUSHJ P,GETQ		;Get a queue block for glitching request
	MOVEM AC2,QFREE(AC1)	;Amount to adjust DMPPXY by when xfer finishes
	IMULI AC2,3		;There will be 2 padding chars for each ADD-ROW
	JUMPGE AC2,DMSHF2
	EXCH AC2,(P)		;Use DEL-ROWs at top ADD-ROWs at bottom
DMSHF2:	MOVMM AC2,QDMCNT(AC1)	;Number of chars to output
	MOVEM AC3,QXY(AC1)	;Set up cursor position for output (LH≡X=0)
	SKIPG (P)
	SKIPA AC3,[440700,,DELRS] ;Moving up, put out DELETE-ROW chars in ID mode
	MOVE AC3,[440700,,ADDRS]  ;Moving down, put out ADD-ROW chars in ID mode
	MOVEM AC3,QTAKR(AC1)
	MOVEI AC3,GLTCHX	;Call GLTCHX when done, to fix DMPPXY
	HRLM AC3,QFREE(AC1)
	MOVEI AC3,DMQUOT!IDON!DMXUSR	;Quote all output chars, be in ID mode,
	MOVEM AC3,QFLAGS(AC1)		; and call indicated routine when done
	MOVEI AC3,DMPPXY(UUO)
	MOVEM AC3,QXYLOC(AC1)	;Pass address of DMPPXY for updating when done
	PUSHJ P,QDMGLC		;Queue the glitch in PP queue
	CAML TAC,DPYHGT(DDB)	;Is last line of PP before last line on screen?
	JRST DMQGL2		;No, this is easy case
	PUSHJ P,GETQ		;Must move text below PP back up or down
	MOVEM TAC,QXY(AC1)
	SKIPG AC2,(P)
	SKIPA AC3,[440700,,ADDRS] ;Moved up, use ADD-ROWs to move other stuff down
	MOVE AC3,[440700,,DELRS]  ;Moved down, use DELETE-ROWs to move stuff up
	MOVEM AC3,QTAKR(AC1)
	MOVMM AC2,QDMCNT(AC1)	;Number of chars to output
	MOVEI AC3,DMQUOT!IDON	;Quote all output chars and be in ID mode
	MOVEM AC3,QFLAGS(AC1)
	PUSHJ P,QDMGLC		;Queue second half of glitching
DMQGL2:	SUB P,[1,,1]		;Flush data from stack
	SOSLE DMGLCH(UUO)	;This should never go negative if we do this right
	JRST DMQGLC
DMPPST:	JUMPE AC1,CPOPJ		;If we didn't queue anything, quit now
	EXCH DAT,DDB		;Dpy header into DAT for STRTDM
	PUSHJ P,STRTDM		;Start DM tty
	EXCH DAT,DDB		;Restore things
	POPJ P,

;Here when glitching xfer has just finished.  Fix up DMPPXY.
GLTCHX:	SKIPGE LEPOS(J)		;Is line editor in PP?
	JRST GLTCHZ		;No (MAYBE WE SHOULD MAKE SURE IT REALLY ISN'T)
	HRRE AC2,QFREE(TAC)	;Yes, we just moved it too
	ADDB AC2,DMLEXY(J)	;Adjust Line Editor position too
	JUMPGE AC2,GLTCHZ
	MOVE AC2,DPYHGT(J)
	ADDM AC2,DMLEXY(J)
GLTCHZ:	HRRE AC2,QFREE(TAC)	;Get negative of number of lines in glitch
	ADDB AC2,@QXYLOC(TAC)	;Add into DMPPXY
	JUMPGE AC2,CPOPJ
	MOVE AC2,DPYHGT(J)	;Get size of screen
	ADDM AC2,@QXYLOC(TAC)	;Readjust PP position onto screen
	POPJ P,

;Here when xfer that caused automatic holding has finished.
DMSTHD:	HRRZ AC2,QFREE(TAC)	;Get address of DPHOLD cell
	SETOM (AC2)		;Hold now
	MOVE DAT,QWAKE(TAC)
	SETZM QWAKE(TAC)	;Don't let DEQ plant request
	JRST DPYTIM		;Plant clock req for DPYTYP to force out stars

;Here to flush all regular PP text xfers from PP queue.
CHASPP:	OFFSCN			;Don't let anything change while we think.
	SKIPA TAC,DMPPPT(DDB)	;Get pointer to first entry in queue
CHASP3:	POP P,TAC
	ANDI TAC,-1
	CAIN TAC,DMPPPT-QLINK(DDB) ;Does this pointer point to header?
	JRST SCNONJ		;Yes, all done
	PUSH P,QLINK(TAC)	;Remember pointer to next queue entry
	MOVE AC1,QFLAGS(TAC)	;Get flag word
	TRNN AC1,QUO177		;Is it a PP text xfer?
	JRST CHASP3		;No, might be a glitch or erasure or tab setting
	SETZM QWAKE(TAC)	;Don't plant clock request when dequeueing
	PUSHJ P,DEQ		;Dequeue this entry.
	JRST CHASP3		;Note that we don't call routine in LH(QFREE)
>;FTDM
;START DAMMIT USUAL QLINE QFIELD QHPOS QLINK QWAKE QCOUNT QTIME QINSTR QLENGTH QFLAGS QTAKR QDMCNT QXY QFREE QPUTR
SUBTTL DATA DISK SERVICE ROUTINE - JAM, DEC. 1970

; THESE ROUTINES ARE CALLED BY THE FOLLOWING IN APRINT
;	SOSGE DDCNT
;	JRST DDCLK
;	SKIPE DDSTART
;	JRST DDSTRT
;APRADD:
; THE DATA DISK ROUTINES KNOW ALL ABOUT THE PAGE PRINTER
; AND THE PIECE OF GLASS MECHANISM. TRANSFERS ARE STARTED
; BY PLACING AN ADDRESS IN THE QUEUE WITH THE LEFT HALF GIVING
; THE TYPE OF TRANSFER.

; HERE ARE THE DD HARDWARE BITS
; CONO BITS

START←←100	; STARTS TRANSFER
RESET←←10	; RESETS INTERRUPT BIT
ENB←←40		; INTERRUPT ENABLE
LOSENB←←400	; ENABLE LATE FLAG INTERRUP
DAMMIT←←20	; MAKES TRANSFER GO OUT ON SPECIFIC FIELD
EXECM←←1000	; EXEC MODE, ALLOWS ONLY ONE CHANNEL SELECT
DDNXM←←2000	; NON-EX MEM FLAG
USUAL←←START!ENB!LOSENB!DAMMIT!APRCHN

; CONI BITS
FIELD←←40	; FIELD BIT
INT←←20		; INTERRUPT BIT
LOSE←←200	; LATE FLAG

; DD TASKS ARE QUEUED UP IN SMALL BLOCKS IN THE FOLLOWING FORM:

		; FIRST WORD CONTAINS XWD <RELEVANT DATA BLOCK>,<ROUTINE>
QLINE←←1	; XWD <STARTING LINE #>,<ENDING LINE #>
QFIELD←←2	; 0 FOR EVEN FIELD, -1 FOR ODD FIELD
QHPOS←←3	; XWD <HPOS1>,<HPOS2> FOR CURSOR TRANSFERS. ZERO ERASES CURSORS.
QLINK←←4	; LINKAGE WORD. XWD <BACKWARD LINK OR 0>,<FORWARD LINK OR 0>
QWAKE←←5	; CONTAINS JOB NUMBER TO WAKE UP, OR CLOCK REQUEST TO PLANT
QCOUNT←←6	; ADDRESS OF WORD TO DECREMENT WHEN THIS TASK DONE. WHEN ZERO, WAKE UP VIA QWAKE WHOMEVER
QTIME←←7	; COUNT DOWN OF NUMBER OF FAILURES
QINSTR←←10	; INSTRUCTION TO XCT WHEN DEQUEING BLOCK (COUNTS DOWN NPPXFR)
↑QLENGTH←←11	; LENGTH OF A TASK BLOCK
;If you change QLENGTH, then change QTEXTL below too.

;DMs use same size block for queued transfer requests, with (some) different names

↑QFLAGS←←0	; LH: dpy header address.  RH: flags for xfer.
↑QTAKR←←1	; byte pointer for unpacking text being output
↑QDMCNT←←2	; byte count for same
↑QXY←←3		; X-Y position of cursor for next character
↑QLINK←←QLINK	; <backward link>,,<forward link>   Neither link is ever zero.
↑QWAKE←←QWAKE	; Number of job to wake up, or clock request to plant (just like DD)
↑QCOUNT←←QCOUNT	; Address of system word to decrement when this task done (like DD)
↑QFREE←←7	; In Line Editor xfer: # of free bytes.
		; In User xfer: <routine to call when done>,,<FS block addr>
↑QINSTR←←QINSTR	; DEQ (DD dequeueing routine) is used also by DM and XCTs this word
↑QXYLOC←←11	; LE & PP: Absolute ptr to X-Y position word for next char
↑QPUTR←←12	; In Line Editor xfer: byte pointer. In User xfer: addr of user flag
↑QTEXT←←13	; Location of first word available for actual text being queued
↑QTEXTL←←20-2-QTEXT	; Number of words available at QTEXT to end of block
;QDDR DOXFR

; CLOCK LEVEL QUEING SCHEME. PLANTS TASKS IN QUEUE AND LEAVES.
; LAST TASK TO FINISH PLANTS CLOCK REQUEST TO TRANSFER MORE DATA.

QDDR:	MOVE AC3,VPOS(UUO)	; PICK UP VERTICAL POSITION
	SUBI AC3,1		; DON'T GO ALL THE WAY TO THE CURRENT LINE
	MOVEM AC3,VP(UUO)	; STORE IT
	PUSHJ P,GETQ		; GET A TASK BLOCK
	PUSH P,AC1		; SAVE ADDRESS OF FIRST TASK BLOCK
	PUSHJ P,GETQ		; GET ANOTHER TASK BLOCK
	MOVE AC2,(P)		; PICK UP ADDRESS OF FIRST TASK BLOCK TOO
	HRR DAT,TAC1		; PUT IN LINE NUMBER AS DATUM OF CLOCK REQUEST
	MOVEM DAT,QWAKE(AC1)	; PUT THE OUTPUT BUFFER ADDRESS AS WAKEUP WORD
	MOVEM DAT,QWAKE(AC2)
	MOVEI AC3,PPENQ(UUO)	; COUNT US DOWN ON THE PAGE PRINTER COUNTER
DOXFR:	AOS (AC3)		; BUMP TASK COUNT BY TWO
	AOS (AC3)
	SETZM PPVIRG(UUO)	; NOTE THAT SOMETHING HAS GONE OUT ON THIS PIECE OF PAPER
	MOVEM AC3,SC(UUO)	; SAVE THE COUNT ADDRESS, IF ANY, FOR FUTURE REFERENCE
	MOVEM AC3,QCOUNT(AC1)
	MOVEM AC3,QCOUNT(AC2)
	SETZM QFIELD(AC1)	; SEND ONE OUT ON ONE FIELD
	SETOM QFIELD(AC2)	; AND THE OTHER OUT ON THE OTHER
	HRLM UUO,(AC1)
	HRLM UUO,(AC2)		; SAVE PAGE PRINTER CONTROL BLOCK ADDRESS AS DATA BLOCK ADDRESS
	MOVEI AC3,PPXFR		; PICK UP ADDRESS OF I-LEVEL SUBROUTINE
	HRRM AC3,(AC1)		; PLACE IT IN ROUTINE ADDRESS POSITION
	HRRM AC3,(AC2)
	SKIPN GLTCH(UUO)	; IS THIS A WHOLE SCREEN TRANSFER?
	JRST DPTDL		; NO, JUST DO ONE LINE
	SETZM GLTCH(UUO)	; WE ARE DONE GLITCHING
	EXCH DAT,UUO		; PICK UP PAGE PRINTER CONTROL BLOCK ADDRESS
	PUSHJ P,POSLIN		; GET LINE NUMBER OF FIRST LINE OF TRANSFER
	EXCH DAT,UUO
	CAML AC3,VPOS(UUO)	; IS THERE REALLY A PAGE HERE?
	JRST NOPAGE		; NO!
	HRLM AC3,QLINE(AC1)
	HRLM AC3,QLINE(AC2)	; THAT WILL BE STARTING LINE NUMBER ON BOTH FIELDS
	MOVE AC3,VP(UUO)	; PICK UP NUMBER OF LAST LINE OF TRANSFER
	HRRM AC3,QLINE(AC1)	; THIS WILL BE ENDING LINE NUMBER
	HRRM AC3,QLINE(AC2)
	PUSHJ P,QBLOCK		; QUEUE UP FIRST TASK
	POP P,AC1		; GET ADDRESS OF SECOND TASK BACK
	PUSHJ P,QBLOCK		; QUEUE IT UP
;QDD1 NOPAGE

; WE GET HERE AT CLOCK LEVEL IN THE MIDDLE OF QUEUEING UP A WHOLE SCREEN REQUEST.
; WE HAVE PUT IN THE TEXT REQUESTS AND ARE NOW GOING TO PUT IN THE ERASURE
; REQUEST.

	MOVE AC2,VP(UUO)	; FIRST, IS THERE ANYTHING TO DO?
	MOVEM AC2,LLW(UUO)	; UPDATE LAST LINE WRITTEN
	CAML AC2,GLW(UUO)
	POPJ P,			; NO, WE ARE DONE
	PUSHJ P,GETQ
	PUSH P,AC1		; GET ANOTHER TASK BLOCK AND SAVE ITS ADDRESS
	PUSHJ P,GETQ		; GET ONE FOR EACH ERASURE FIELD
	MOVE AC3,(P)		; GET BACK ADDRESS OF FIRST ONE
	HRLM UUO,(AC1)		; PUT IN PAGE PRINTER CONTROL BLOCK ADDRESS
	HRLM UUO,(AC3)
	MOVEI AC2,ERASE		; WE WILL CALL THE ERASE CODE
	HRRM AC2,(AC1)
	HRRM AC2,(AC3)
	MOVEM DAT,QWAKE(AC1)	; PUT THE CLOCK REQUEST WORD IN
	MOVEM DAT,QWAKE(AC3)
	MOVE AC2,SC(UUO)	; PICK UP COUNT ADDRESS
	MOVEM AC2,QCOUNT(AC1)	; COUNT DOWN THROUGH IT.
	MOVEM AC2,QCOUNT(AC3)
	SETZM QFIELD(AC1)	; SEND THEM OUT ON OPPOSITE FIELDS
	SETOM QFIELD(AC3)
	MOVE AC2,GLW(UUO)	; ERASE TO THE LAST LINE WRITTEN
	HRRM AC2,QLINE(AC1)
	HRRM AC2,QLINE(AC3)
	MOVE AC2,VP(UUO)	; ERASE FROM THE CURRENT POSITION
	MOVEM AC2,GLW(UUO)	; UPDATE LAST LINE WRITTEN
	HRLM AC2,QLINE(AC1)
	HRLM AC2,QLINE(AC3)
	SKIPN SC(UUO)		; IS THERE A COUNT ADDRESS?
	JRST QDD1		; NO, DON'T INCREMENT IT!
	AOS @SC(UUO)		; YES, BUMP IT TWICE
	AOS @SC(UUO)
QDD1:	PUSHJ P,QBLOCK		; QUEUE UP THE FIRST ONE
	POP P,AC1
	JRST QBLOCK		; AND THE SECOND ONE

; WE GET HERE IF THERE REALLY ISN'T ANYTHING ON THE PAGE

NOPAGE:	PUSHJ P,WAKEQ		; WAKE UP ANYONE WHO'S THERE
	PUSHJ P,GIVQB		; JUST RETURN EVERYTHING TO FREE STORAGE.
	POP P,AC1
	PUSHJ P,WAKEQ
	JRST GIVQB
;DPTDL DPYTLX

; WE GET HERE TO QUEUE UP A ONE LINE REQUEST.

DPTDL:	MOVE AC3,LLW(UUO)	; PICK UP LINE NUMBER
	CAMLE AC3,VP(UUO)	; IS THIS PAST WHERE WE ARE SUPPOSED TO BE?
	MOVE AC3,VP(UUO)	; YES, USE OUR ARGUEMENT
	HRLM AC3,QLINE(AC1)	; STORE THIS
	HRLM AC3,QLINE(AC2)
	MOVE AC3,VP(UUO)	; END UP ON LINE THE CALLER REQUESTED
	HRRM AC3,QLINE(AC1)
	HRRM AC3,QLINE(AC2)
	MOVEM AC3,LLW(UUO)	; AND THIS IS NOW THE LAST LINE WRITTEN
	PUSHJ P,QBLOCK		; PUT THIS BLOCK IN THE QUEUE
	POP P,AC1		; GET BACK ADDRESS OF SECOND BLOCK
	JRST QBLOCK		; QUEUE IT UP TOO

; WE GET TO THIS ROUTINE WHEN THE BUFFER IS EMPTY.  SCANNER IF OFF.

DPYTLX:	JUMPL UUO,DPYDON	; III DISPLAYS CAN GO ON TO TTYSER NOW
IFN FTDM,<
	SKIPE GLTCH(UUO)	; Make sure we update screen if glitched
	JRST .+3
>;FTDM
	SKIPN DPYCHR(UUO)	; HAS AT LEAST ONE CHARACTER BEEN TYPED?
	JRST DPYDON		; NO, EXIT
	SETZM DPYCHR(UUO)	; CLEAR TYPEOUT FLAG
	MOVN AC1,DPHPOS(UUO)	; PICK UP HORIZONTAL POSITION POINTER
	PUSH P,DAT		; SAVE TTY BUFFER ADDRESS
	HRR DAT,UUO		; PUT PAGE PRINTER CONTROL BLOCK ADDRESS IN DAT FOR REFLIX
	MOVE AC2,LLW(UUO)	; SEE IF PAGE PRINTER IS UP TO DATE
	CAMN AC2,VPOS(UUO)	; COMPARE LAST LINE WRITTEN WITH VERTICAL POSITION
	CAME AC1,LNLNGT(UUO)	; IF NOT AT COLUMN ZERO,
	JRST .+2		; NEED TO PUT IN REQUEST
	SKIPE GLTCH(UUO)	; NEED TO GLITCH? SOLVES THE SINGLE LINE GLITCH BUG.
	PUSHJ P,REFLIX		; PUT IN A SINGLE LINE REQUEST, WHICH MAY DRAW SCREEN
	POP P,DAT
	HRRZ AC1,HEDPTR(UUO)	; PICK UP POINTER TO DPY PROGRAM HEADER
	MOVSI AC2,DPLED		; MAKE A POINTER TO THE LINE EDITOR QUEUE ROUTINE
	HRR AC2,AC1		; AND MAKE IT INTO A CLOCK REQUEST WORD
	SETO AC3,		; SEE IF LINE EDITOR CLOCK FLAG IS SET
	EXCH AC3,LECLK(AC1)	; IF NOT SET, SET IT NOW
	JUMPL AC3,DPYDON	; IF ALREADY IN, LEAVE NOW
	CONO PI,PIOFF		; NOT IN, PLANT CLOCK REQUEST
	IDPB AC2,CLKQ
	CONO PI,PION
	JRST DPYDON
;LEERSN RFPCS LEERS LEERS3 LEPGC LEPGC REFLIX REFLINE

; THIS ROUTINE QUEUES UP AN ERASURE REQUEST FOR THE LINE EDITOR <ESC>C COMMAND

↑LEERSN:PUSH P,DAT
	MOVEI DDB,(DAT)		;GIVE PPSEL PTR TO DPY HEADER
	PUSHJ P,PPSEL0		;SELECT AND ACTIVATE P OF P NO. 0 -- ME
	POP P,DAT
	TLCA DAT,LEERSN≠PPNST2	;CHANGE CLK RQ TO CALL PPNST2 to normalize & redraw screen
↑RFPCS:	HRLI DAT,LERFP		;LERFP redraws screen
	SKIPE III(DAT)
	JRST LEPGC
	MOVEI AC2,LEENQ2(DAT)	;ENTER HERE FOR SOMETHING ELSE TO BE QUEUED AFTER THE ERASE
	AOSA LEENQ2(DAT)
↑LEERS:	MOVEI AC2,		;Here to erase PP
	SKIPGE AC3,PRGNUM(DAT)
	JRST LEPGC2		;DIFFERENT "ERASE" ON III
	SETOM LECC(DAT)		;Flag ESC C done
	TLNE AC3,DMLIN
	JRST LEPDM		; DM routine to erase screen
	PUSHJ P,GETQ		; GET A TASK BLOCK
	MOVEM AC2,QCOUNT(AC1)
	MOVEM DAT,QWAKE(AC1)
LEERS3:	MOVE AC2,[XWD 1,=40]
	MOVEM AC2,QLINE(AC1)
	SETZM QFIELD(AC1)	; START ON FIELD ZERO
	HRLM DAT,(AC1)		; GIVE IT DPY PROGRAM HEADER ADDRESS
	MOVEI AC2,WSE		; GO TO THE ERASURE ROUTINE
	HRRM AC2,(AC1)
	SETOM LEVP(DAT)		;TELL DPLED OUR CURSORS BIT THE DUST
	SETOM LECVP(DAT)
	MOVEI DDB,(DAT)		; QBLOCK EXPECTS DPY HEADER IN DDB
	JRST QBLOCK		; PUT IT IN THE QUEUE

LEPGC:	HLRZ TAC,DAT
	PUSH P,DAT
	PUSHJ P,(TAC)		;DO PP STUFF FIRST
	POP P,DAT
LEPGC2:	MOVEI DDB,(DAT)
	JRST PGCLR

; THE LINE EDITOR PLANTS A CLOCK REQUEST TO REFLINE WHEN IT
; IS DONE TRANSFERRING A LINE INTO THE PAGE PRINTER BUFFER.
; WE SEND OUT THE LINE IT HAS JUST TRANSFERRED.

;Here from DPYTLX for DD and DM.
REFLIX:	HRRZ AC1,TPJMP(DAT)	;Pick up jump to text
	CAIN AC1,DISNOP		;Is it really a jump?
	POPJ P,			;No, don't queue anything
	TLNE UUO,DMLIN
	JRST QDMR		;Use DM routine for queueing xfers
	MOVEI AC3,PPENQ(DAT)	;HERE TO QUEUE TASK FOR PAGE PRINTER
	JRST REFLN2

;Here only for Data Disc.
REFLINE:
	MOVE DDB,HEDPTR(DAT)
	MOVEI AC3,PPNQT(DAT)	;QUEUE TASK FOR LE. USE "OTHER COUNT DOWN CELL"
	HRRZ AC1,TPJMP(DAT)	; PICK UP JUMP TO TEXT
	CAIN AC1,DISNOP		; IS IT REALLY A JUMP?
	POPJ P,			; NO, DON'T BOTHER
REFLN2:	PUSH P,AC3		;SAVE ADDRESS OF COUNT DOWN CELL
	PUSHJ P,GETQ		; GET US A TASK BLOCK
	EXCH AC1,(P)		;(ICK) SAVE AC1 (ADDR OF TASK BLOCK) ON TOP OF STACK
	PUSH P,AC1		;SAVE ADDRESS OF COUNT DOWN CELL IN NEW STACK TOP
	PUSHJ P,GETQ
	MOVE AC2,-1(P)		;GET THE FIRST TASK BLOCK ADDRESS
	MOVE AC3,VPOS(DAT)	; PICK UP VERTICAL POSITION
	MOVEM AC3,VP(DAT)	; SAVE THIS AS ARGUEMENT FOR QDD
	POP P,AC3		;SET ADDRESS OF THE COUNT-DOWN CELL IN AC3
	HRRZ UUO,DAT		; IT EXPECTS THE PAGE PRINTER ADDRESS IN UUO
	SETZM QWAKE(AC1)	; DON'T WAKE UP ANYBODY
	SETZB DAT,QWAKE(AC2)
	JRST DOXFR		; USE QDDR TO DO ALL THIS
;LERFP Q2BLCK LERFP1 GET2Q LERELE PPCLB

; HERE LIES A ROUTINE TO QUEUE UP A WHOLE PAGE TRANSFER WHEN NOT GLITCHING

↑LERFP:	MOVEI DDB,(DAT)
	SKIPE III(DAT)
	JRST PPRST		;RESTART PROG IF III
	HRRZ UUO,CURPP(DAT)	; PICK UP PAGE PRINTER CONTROL BLOCK ADDRESS
	MOVE AC1,HEDPTR(UUO)
	CAIE AC1,(DAT)
	JRST PPCLB		;CURPP IS CLOBBERED OR SOMETHING
	HRRZ AC1,TPJMP(UUO)	; PICK UP JUMP TO TEXT
	CAIN AC1,DISNOP		; IS IT REALLY A JUMP?
	POPJ P,			; NO, FORGET IT
	HLL UUO,PPDPY(UUO)	; GET DISPLAY-TYPE BIT
	TLNN UUO,DDDLIN
	JRST LERDM		;DATAMEDIA
	SKIPE PPENQ(UUO)	; IS THERE ANYTHING IN THE PAGE PRINTER'S QUEUE?
	JRST LERFP1		; YES, IT WILL GET CAUGHT LATER
	SETZM PPVIRG(UUO)	; NO LONGER A VIRGIN PIECE OF PAPER
	JSP AC3,GET2Q
	MOVEI AC3,LEENQ2(DAT)
	MOVEM AC3,QCOUNT(AC1)
	MOVEM AC3,QCOUNT(AC2)
	MOVEI AC3,2
	ADDM AC3,LEENQ2(DAT)
	HRR AC3,DAT
	HRLI AC3,LERELE
	MOVEM AC3,QWAKE(AC1)
	MOVEM AC3,QWAKE(AC2)
	HRLM UUO,(AC1)		; PUT IN ADDRESS OF PAGE PRINTER CONTROL BLOCK
	HRLM UUO,(AC2)
	MOVEI AC3,PPXFR		; THE I-LEVEL SUBROUTINE ADDRESS
	HRRM AC3,(AC1)
	HRRM AC3,(AC2)
	EXCH DAT,UUO		; PICK UP THE NUMBER OF THE LINE AT THE TOP OF THE PAGE
	PUSHJ P,POSLIN
	EXCH DAT,UUO
	HRLM AC3,QLINE(AC1)	; PUT IN THAT AS OUR STARTING LINE NUMBER
	HRLM AC3,QLINE(AC2)
	MOVE AC3,VPOS(UUO)	; PICK UP THE CURRENT POSITION OF THE BOTTOM OF THE PAGE
	HRRM AC3,QLINE(AC1)
	HRRM AC3,QLINE(AC2)
Q2BLCK:	PUSHJ P,QBLOCK		; QUEUE THEM UP
	POP P,AC1
	JRST QBLOCK		; QUEUE UP THE LAST TASK AND LEAVE

LERFP1:	SETOM GLTCH(UUO)	; FORCE THE PAGE PRINTER TO REFRESH NEXT TIME AROUND
	POPJ P,

GET2Q:	PUSHJ P,GETQ		; OTHERWISE, GET A TASK BLOCK TO DO IT OURSELVES
	PUSH P,AC1
	PUSHJ P,GETQ
	HRRZ AC2,(P)
	SETZM QFIELD(AC1)	; SEND THESE OUT ON OPPOSITE FIELDS
	SETOM QFIELD(AC2)
	JRST @AC3

;REFRESH LINE EDITOR
LERELE:	EXCH DAT,J
	PUSHJ P,QLETXT		;QLETXT IS IN LINED
	EXCH DAT,J
	POPJ P,

PPCLB:	PUSHACS
	PUSHJ P,DISDAT
	PUSHJ P,DISMES
	ASCIZ /CURPP CLOBBERED AT LERELE
/
	DEBCHE
	POPACS
	POPJ P,
;LERDM LERDM2 LEPDM LEPDM2 LEPDM3 DMLED DMLED4 DMLED5 DMLED7 DMLED9 DMEOSL DMEOS2 DMFLUS TBDONE STRTDM DMNDDB

;Here from LERFP to redraw whole PP
LERDM:
IFE FTDM,<
	PUSHJ P,NODMDP		;CAN'T GET HERE YET I CLAIM!--ME
	JRST 4,AUTOLOAD
>;¬FTDM
IFN FTDM,<
	SETZM DMLAST(UUO)	;Make it type out whole page
;PPXSIZ enters here to force out any glitches.
LERDM2:	PUSHJ P,PPHLD2		;Unhold us
	HRRZ AC1,TPJMP(UUO)	;Is PP active?
	CAIN AC1,DISNOP
	POPJ P,			;No
	MOVSI DAT,LERELE	;Routine to wake up when xfers done
	HRRZ TAC1,DDB		;QDMPP puts this data into clock req word QWAKE
	JRST QDMR		;Now queue up whole page request
>;FTDM

;Here from LEERS (et al.) to do ESC C on DM.
;LH(DAT) is routine to call after erasure w/RH(DAT) preserved (dpy header).
;RH(AC2), if non-zero, is address of cell just AOSed to count down on erase done.
LEPDM:
IFE FTDM,<
	PUSHJ P,NODMDP		;CAN'T GET HERE YET I CLAIM.--ME
	JRST 4,AUTOLOAD
>;¬FTDM
IFN FTDM,<
	SKIPE AC2		;Any cell incremented?
	SOSA (AC2)		;Yes, decrement it since we don't queue the erasure
	HRLI DAT,CPOPJ		;No cell, no routine to call
	OFFSCN			;Don't let ch5 in while we flush the queues
	MOVEI AC2,DMWHO(DAT)
	PUSHJ P,DMFLUS		;Flush entries in WHO queue
	MOVEI AC2,DMUSER(DAT)
	PUSHJ P,DMFLUS		; and in user queue
	MOVEI AC2,DMPPPT(DAT)
	PUSHJ P,DMFLUS		; and in page printer queue
	MOVEI AC2,DMSPPT(DAT)
	PUSHJ P,DMFLUS		; and in special xfer queue
	MOVEI AC2,DMLEPT(DAT)
	PUSHJ P,DMFLUS		; and in line editor queue
	PUSH P,DAT		;Save dpy header
	MOVE J,DAT		;Dpy header for LEPDM2
	PUSHJ P,LEPDM2
	HLRZ AC1,DAT		;Possible routines: CPOPJ, PPNST2, LERFP
	PUSHJ P,(AC1)		;Call clock level routine now instead of later
	POP P,DAT		;Dpy header for STRTDM
	JRST STRTDM

;Enter here from DPYMAKE at DPYM9, w/dpy header in J
LEPDM2:	PUSHJ P,DMSETQ		;Initialize quicky buffer to empty
	MOVEI AC2,MASTER
	IDPB AC2,DSER
	MOVEI AC2,CANCEL
	IDPB AC2,DSER
	MOVEI AC2,2
	MOVEM AC2,DMQKCT(J)
	SETZM DMFLAG(J)		;Note that all DM modes are off and tabs not set
	MOVE AC2,PRGNUM(J)
	MOVE AC2,LINTAB(AC2)
	TLNE AC2,TBXPND		;Does this DM have "hardware" tabs?
	JRST SCNONJ		;No
LEPDM3:	PUSHJ P,GETQ		;TTY TABS command will enter here someday to set tabs.
	MOVE AC2,[440700,,TABSET]
	MOVEM AC2,QTAKR(AC1)
	MOVEI AC2,LTABSE*5
	MOVEM AC2,QDMCNT(AC1)	;Number of chars in request.
	MOVEI AC2,DMQUOT!DMXUSR	;Quote everything and call routine when done
	HRL AC2,J		;Dpy header
	MOVEM AC2,QFLAGS(AC1)
	MOVSI AC2,TBDONE	;Routine to call when done
	MOVEM AC2,QFREE(AC1)
	SETZM QCOUNT(AC1)	;Don't wake anybody up over this trivial task
	SETZM QXY(AC1)		;Upper left corner
	SETZM QXYLOC(AC1)	;Zero the job number slot so DMUPG won't flush us.
	MOVEI AC2,DMSPPT-QLINK(J)
	PUSHJ P,QDM		;Queue tab setting in special queue
	JRST SCNONJ

;Here in ch5 when tab setting xfer has finished.
TBDONE:	MOVEI AC2,TBSSET
	IORM AC2,DMFLAG(J)	;Tabs have now been set.
	POPJ P,

;Routine to dequeue all the entries in any particular DM queue.
;Call with pointer to queue header word in AC2.
↑DMFLUS:PUSH P,AC2		;Save pointer to actual header word
	SUBI AC2,QLINK		;Make value for matching pointer to header
	PUSH P,AC2
	JRST DMFLU2

DMFLU3:	PUSHJ P,DEQ
DMFLU2:	HRRZ TAC,@-1(P)		;Get pointer to first entry now in queue
	CAME TAC,(P)
	JRST DMFLU3
	SUB P,[2,,2]		;Back to header--all done
	POPJ P,

;Here from clock request because couldn't get free storage
DMLED0:	MOVE J,DAT
	OFFSCN			;Turn off scanner channel
	SETZM DMCLK(DAT)
	PUSHJ P,DMLED		;Expects dpy header in J
	ONSCN			;Turn on scanner channel
	POPJ P,

;Here if we couldn't get free storage for copy of LE buffer--try again later
DMLED5:	SETO AC3,
	EXCH AC3,DMCLK(DAT)
	JUMPL AC3,CPOPJ		;Request already in
	HRLI DAT,DMLED0
	JRST DPYTIM		;Plant clock request from DAT
>;FTDM

;J and DAT point to dpy header
;UUO points to current PP
;X-Y is specified by LELINE(DAT) and PPHPOS(DAT)
;Get here at clock level to redraw whole Line Editor on DM
DMLED:
IFE FTDM,<
	PUSHJ P,NODMDP
	JRST 4,AUTOLOAD
>;¬FTDM
IFN FTDM,<
	MOVEI AC2,DMLEPT(J)
	PUSHJ P,DMFLUS		;Make sure nothing is in line editor queue
	HRRZ TAC1,PRGNUM(DAT)	;TTY number
	SKIPGE LETAB(TAC1)	;Editor not initialized?
	SKIPG FCPOS(DAT)	;No, editor empty?
	JRST DMLED7		;Yes, just queue up erasure request
	SKIPE AC1,DMFS(DAT)	;Got free storage for copy of line editor text?
	JRST DMLED4		;Yes
	MOVEI AC3,BUFL+1	;No, get some; extra word for positioning cursor
	PUSHJ P,FSGET
	JRST DMLED5		;Replant clock request
	MOVEM AC1,DMFS(DAT)	;Remember where it is
DMLED4:	HRLI AC1,LEBUF(DAT)	;Address of actual text
	MOVE AC2,AC1
	BLT AC1,BUFL-1(AC2)	;Copy line editor text into FS
	PUSHJ P,GETLEQ
	SETZM QFREE(AC1)	;Don't let anyone stuff text in this block
	MOVE AC2,DMFS(DAT)	;Get back the address of copy of LE text
	HRLI AC2,440700
	MOVEM AC2,QTAKR(AC1)
	MOVEI AC3,1
	TDNE AC3,(AC2)		;Is this a text word?
	AOJA AC2,.-1		;Yup
	SUBI AC2,1		;Point to last text word
	HRLI AC2,100700		;Make byte pointer to LF that ends editor
	MOVEI AC3,177		;Tell TTYSER we are quoting next character
	IDPB AC3,AC2
	MOVEI AC3,14
	IDPB AC3,AC2
	MOVE AC3,CHP(DAT)	;Get cursor horiz pos
	XORI AC3,140
	IDPB AC3,AC2
	MOVE AC3,CVP(DAT)	;Get cursor vert pos
	SUBI AC3,1		;Normalize for DM
	XORI AC3,140
	IDPB AC3,AC2
	SUB AC2,DMFS(DAT)
	MOVEI AC2,(AC2)
	IMULI AC2,5
	ADDI AC2,3		;The LF was replaced with 177,FF,X,Y,0,0
	MOVEM AC2,QDMCNT(AC1)	;Number of bytes to output
	MOVSI AC2,CHASTE!DMATXY!BETWEE!DMXLE ;Make sure old line gets erased
DMLED9:	MOVEM AC2,DMLEFL(J)	
	MOVE AC2,LELINE(DAT)
	SUBI AC2,1		;Normalize line number for DMXMT
	HRL AC2,PPHPOS(DAT)
	MOVEM AC2,DMLEXY(DAT)	;Store X-Y position where DMXMT will see it
	SETZM LETXC(DAT)	;Note text is now up to date
↑STRTDM:
	HRRZ TAC1,PRGNUM(DAT)	;Get line number
	HLL TAC1,LINTAB(TAC1)	; and line bits
	PUSH P,DDB
	HRRZ DDB,TTYTAB(TAC1)	;Get tty DDB address
	JUMPN DDB,STRTD2	;Jump if there is one
	PUSHJ P,DDBSRC		;None there, make one
	JRST DMNDDB
STRTD2:	PUSH P,DAT
	PUSHJ P,TYPT2		;Start tty if necessary
	POP P,DAT		;Restore dpy header
	POP P,DDB		; and whatever
	POPJ P,

PRINTX DMLED7 should make sure 177 and EEOL go into same queue entry
DMLED7:	MOVEI CHR,EEOL
	PUSHJ P,QUODMC		;Put out a quoted char to DM
	MOVSI AC2,DMATXY!BETWEE!DMXLE ;Flags needed
	JRST DMLED9		;Now start up DM, if necessary

DMNDDB:	POP P,DDB
	PUSHACS
	PUSHJ P,DISMES
	ASCIZ /AT STRTDM TO START DM TYPEOUT BUT NO TTY DDB, AND CAN'T MAKE ONE.
LINE NUMBER IN TAC1.  DPY HEADER IN DAT.
/
	PUSHJ P,DISFLU
	POPACS
	PUSHJ P,WDDTCA
	POPJ P,

;Here to erase previous extra lines no longer used by LE, w/number of CRLFs in AC3
DMEOSL:	PUSH P,AC3
	PUSHJ P,GETQ
	POP P,AC3
	MOVEI AC2,CHASTE
	HRL AC2,J
	MOVEM AC2,QFLAGS(AC1)
	ADD AC3,LELINE(DAT)	; ADD IN VERTICAL POSITION
	MOVEM AC3,QXY(AC1)	; This will start at next line since DM=LE-1
	MOVE AC3,LEVP(DAT)	; PICK UP LAST VERTICAL POSITION
	ADD AC3,LENCRS(DAT)	; Make it number of last line formerly used by LE
	SUB AC3,QXY(AC1)	; Number of lines to erase
	MOVEM AC3,QDMCNT(AC1)
	MOVE AC3,[440700,,DMLFS];Put out appropriate number of plain LFs
	MOVEM AC3,QTAKR(AC1)
	SETZM QCOUNT(AC1)	;Don't wake anyone when done
	MOVEI AC2,DMSPPT-QLINK(J)
	JRST QDM		;Queue it in special queue
>;FTDM
;DPLED DPLEVS DPLEOK

; HERE IS THE MIGHTY LINE EDITOR AND CURSOR GENERATOR.
; THIS ROUTINE SINGLEHANDEDLY SENDS OUT LINE EDITOR TRANSFERS, LINE EDITOR
; ERASURES, ALL CURSORS AND ALL CURSOR ERASURES.

↑DPLED:	HGMAC(33)
	SKIPE LEENQ(DAT)	; DO WE HAVE SOMETHING IN THE QUEUE ALREADY?
	POPJ P,			; YES, THIS ISN'T SUPPOSED TO HAPPEN!
	HRRZ UUO,CURPP(DAT)	; PICK UP ADDRESS OF PAGE PRINTER CONTROL BLOCK
IFN FTDM,<
	SKIPN DPYCHR(UUO)	;If more PP output waiting, wait for it
>;FTDM
	SKIPE PPENQ(UUO)	; IS THERE ANYTHING IN THE PAGE PRINTER QUEUE?
	JRST DPYTIM		; YES, COME BACK LATER
	OFFSCN			;TURN OFF SCANNER CHANNEL
	MOVE AC1,VPOS(UUO)	; ASSUME WE ARE GOING IN THE USUAL POSITION
	MOVEM AC1,LELINE(DAT)
	MOVE AC1,DPHPOS(UUO)
	ADD AC1,LNLNGT(UUO)
	MOVEM AC1,PPHPOS(DAT)	;INITIALLY ASSUME LINE EDITOR X = PP X
	SKIPL AC3,LEPOS(DAT)
	JRST DPLEVS
	LDB AC3,[POINT 11,AC3,21]
	TRNE AC3,1⊗=10		; EXTEND SIGN BIT
	OR AC3,[-1⊗=10]
	PUSHJ P,@PPDPY(UUO)	;Convert to non-negative line number
	MOVEM AC3,LELINE(DAT)
	SETZB AC1,PPHPOS(DAT)	;NOW LINE EDITOR X IS ALWAYS ZERO
DPLEVS:	HLL UUO,PPDPY(UUO)	;Get display type bit
IFN FTDM,<
	SKIPGE LEPOS(DAT)	;Line editor in normal position in PP?
	JRST DPLEOK		;No
;	EXCH DAT,UUO
;	PUSHJ P,POSLIN		;Get 1st line of PP
;	EXCH DAT,UUO
;	MOVE AC2,DEL(UUO)	;Lines per glitch
;	IMUL AC2,PGSIZ(UUO)	; * glitches per screen
;	ADDI AC3,(AC2)		; + 1st line of PP = line beyond end of PP
PRINTX DMLEVS should also make DM and DD glitch if cursor wraps around off screen.
	MOVE AC2,LELINE(DAT)	;Starting line of LE
	ADD AC2,NCRS(DAT)	; + number of extra lines used by LE
	CAMG AC2,DPYHGT(DAT)	;Does whole LE appear on screen?
	JRST DPLEOK		;Yes
	PUSHJ P,DPYTIM		;No, come back later
	MOVE DDB,DAT		;Set up ACs for GLITCH
	MOVE DAT,UUO
	PUSHJ P,PPHLD2		;Unhold if necessary
	PUSHJ P,GLITCH		;Glitch now
	MOVE UUO,DAT
	MOVSI DAT,DPYTYP	;Wakeup routine for queued xfers
	HRRZ TAC1,PRGNUM(DDB)	;Line number is datum for DPYTYP
	ONSCN
	HRRZ AC1,TPJMP(UUO)	; Is the PP active?
	CAIN AC1,DISNOP
	POPJ P,			; No, don't do anything
	TLNN UUO,DMLIN
	JRST QDDR		; DATA DISC
	JRST QDMR		; DATAMEDIA

DPLEOK:
>;FTDM
	MOVEI AC3,LEENQ(DAT)	; GET ADDRESS OF COUNT WORD
	MOVEM AC3,SC(UUO)	; USE IT TO COUNT DOWN OUR TASKS
	MOVE AC3,PRGNUM(DAT)	; PICK UP DPY NUMBER
	SKIPG J,LETAB(AC3)	; IS THE LINE EDITOR CURRENTLY INITIALIZED??
	JRST DPLGCP		; YES, GET ITS POSITION FROM THE CHARACTER COUNT
IFN FTDM,<
	SKIPL LEPOS(DAT)	;Is vertical pos of LE specified by user?
	JRST DPLGC2		;No
	HRRZ AC2,TTYTAB(AC3)	;Get tty DDB address
	JUMPE AC2,DPLGC2	;If none, can't be suppressing erasures
	MOVE AC2,ACTMOD(AC2)	;Get special activation table bits
	TRNE AC2,SUPERS		;Suppressing erasures?
	TLO UUO,SUPER2		;Yes, flag it to our routines here
>;FTDM
;FALL THRU TO NEXT PAGE
;DPLGC2 DPLGC1 DPTL14 DPLGCP NOLETX

; HERE WE SET UP THE CURSOR POSITION AND START ON THE DECISION TREE

;FELL THRU HERE FROM PREV PAGE
DPLGC2:	MOVEM AC1,CHP(DAT)	; SAVE THE HORIZONTAL POSITION
	MOVE AC1,LELINE(DAT)
DPLGC1:	MOVEM AC1,CVP(DAT)	; AND THE VERTICAL POSITION
	MOVE AC1,LELINE(DAT)	; GET VERTICAL POSITION

IFN FTDM,<
	JUMPLE AC1,NOLETX	;If above screen, don't draw text
	TLNN UUO,SUPER2		;If suppressing erasure of old text, 
	CAMLE AC1,DPYHGT(DAT)	; or if LE is below screen,
	JRST NOLETX		; then don't do anything to text
>;FTDM
	CAMN AC1,LEVP(DAT)	; HAS THE VERTICAL POSITION OF THE LINE EDITOR CHANGED?
	JRST DPTLE1		; NO, SEE IF ANYTHING ELSE HAS CHANGED.
	TLNE UUO,DMLIN
	JRST DPTL12		; Just redraw text if on DM
	PUSHJ P,DPEC		; ERASE THE LINE EDITOR CURSOR
	PUSHJ P,DPEOPC		; ERASE THE PAGE PRINTER CURSOR
	PUSHJ P,DPWT		; WRITE OUT THE TEXT AGAIN.
	MOVE AC1,CVP(DAT)	; PICK UP CURSOR POSITION
	CAMN AC1,LELINE(DAT)	; IS IT THE SAME AS THE PAGE PRINTER POSITION?
	JRST DPTL14		; YES, WRITE OUT BOTH CURSORS ON THE SAME LINE
	PUSHJ P,DPWC		; NO, WRITE OUT THE LINE EDITOR CURSOR
	PUSHJ P,DPWPC		; THEN WRITE OUT THE PAGE PRINTER CURSOR
	JRST DPTLE5		; GO UPDATE STATE OF HISTORY TO REFLECT OUR TRANSFERS.

IFN FTDM,<
NOLETX:	MOVEM AC1,LEVP(DAT)
	SETZM LETXC(DAT)
	SETZM LEMISS(DAT)
	MOVE AC1,NCRS(DAT)
	MOVEM AC1,LENCRS(DAT)
	JRST DPTL1C
>;FTDM

DPTL14:	PUSHJ P,DPWB		; SAME LINE, WRITE OUT BOTH CURSORS AT ONCE
	JRST DPTLE5

DPLGCP:	ADD AC1,LEHPOS(DAT)	; ADD IN LINE EDITOR CURSOR HORIZONTAL POSITION
	JUMPE AC1,DPLGC2	; IF NO DISTANCE INTO LINE, SET POSITIONS TO ZERO
	IDIV AC1,LNLNGT(UUO)	; CONVERT TO NUMBER OF LINES AND DISPLACEMENT INTO LAST LINE
	ADD AC1,LELINE(DAT)	; ADD IN STARTING LINE NUMBER
	MOVEM AC2,CHP(DAT)	; THE REMAINDER IS THE HORIZONTAL POSITION
	JRST DPLGC1		; AND WE NOW HAVE IT ALL!
;DPTLE1 DPTL1A DPTL1B DPTL1C DPTL1D
; WE GET HERE IF THE VERTICAL POSITION OF THE LINE EDITOR HAS NOT CHANGED.
; WE CHECK IF ANYTHING ELSE ABOUT THE LINE MIGHT HAVE CHANGED.

DPTLE1:	JUMPGE J,DPTL1D		;DON'T BOTHER CHECKING EMPTY EDITOR
	MOVE AC1,PPHPOS(DAT)
	EXCH AC1,LSTHP(DAT)
	CAMN AC1,LSTHP(DAT)	;SEE IF LE HAS MOVED HORIZONTALLY
	JRST DPTL1A		;NO
	EXCH DAT,UUO		;LEFIX expects display bit in LH of DAT
	PUSHJ P,LEFIX		;YES - RECALCULATE TABS & LONG-LINE CRLFS
	EXCH DAT,UUO
	SETOM LETXC(DAT)	;TEXT NOW NEEDS WRITING
DPTL1A:	SKIPA AC3,NCRS(DAT)	; WE GET HERE IF THE VERTICAL POSITION IS THE SAME
DPTL1D:	MOVE AC3,NCRS(DAT)	;Empty LE means no extra CRLFs
	CAMGE AC3,LENCRS(DAT)	; NOW HAS THE LINE SHRUNK ANY?
	PUSHJ P,DPEOSL		; YES, ERASE LINES PAST FIRST ONE.
DPTL1C:	TLNE UUO,DMLIN		; No explicit xfers needed for cursor
	JRST DPTL1B		; Just see if need to output text
	MOVE AC1,CVP(DAT)	; PICK UP CURSOR VERTICAL POSITION
	CAME AC1,LECVP(DAT)	; HAS THE CURSOR VERTICAL POSITION CHANGED?
	JRST DPTLE2		; YES, SEE HOW MUCH AND WHERE IT IS NOW.
	MOVE AC1,CHP(DAT)	; IF THE VERTICAL POSITION IS THE SAME,
	CAME AC1,LECHP(DAT)	; THEN HOW ABOUT THE HORIZONTAL POSITION?
	JRST DPTLE3		; DIFFERENT, GO SEND OUT A NEW ONE.
	MOVE AC1,PPHPOS(DAT)	;SEE IF PP CURSOR MOVED
	CAME AC1,LEHP(DAT)
	JRST DPTLE6		; YES, GO SEND IT OUT AGAIN
DPTL1B:	SKIPN LETXC(DAT)	; HAS THE TEXT CHANGED?
	SKIPE LEMISS(DAT)	; OR DID THE LINE EDITOR MISS A BEAT DUE TO AN INVALID BUFFER?
	JRST DPTL12		; YES, SEND OUT THE TEXT AGAIN
	SETZM LECLK(DAT)	; NO, NOTHING AT ALL TO DO!
	MOVE AC1,NCRS(DAT)	; Number of CRLFs in line display has been corrected
	MOVEM AC1,LENCRS(DAT)	; This may fix the E problem of spurious LE erasures
IFN FTDM,<
	TLNE UUO,DMLIN
	PUSHJ P,STRTDM		;Start the DM to ensure proper cursor positioning
>;FTDM
	ONSCN			;TURN ON SCANNER CHANNEL
	POPJ P,
;DPTLE6 DPTLE9 DPTLE7 DPTLE2 DPTLE8 DPTL11 DPTLE3

; LINE EDITOR DECISION TREE. WE GET HERE IF THE LINE EDITOR CURSOR HAS NOT
; MOVED, BUT THE PAGE PRINTER CURSOR HAS(???)

DPTLE6:	MOVE AC1,CVP(DAT)	; ARE THE TWO CURSORS ON THE SAME LINE?
	CAME AC1,VPOS(UUO)
	JRST DPTLE7		; NO, THEY CAN BE SENT OUT SEPARATELY.
DPTLE9:	PUSHJ P,DPWB		; YES, SEND OUT BOTH
	JRST DPTLE4

DPTLE7:	PUSHJ P,DPWPC		; WRITE OUT THE PAGE PRINTER CURSOR ALONE
	JRST DPTLE4		; DO TEXT CHECK AND LEAVE

DPTLE2:	MOVE AC1,LELINE(DAT)	; WE COME HERE IF THE CURSOR VERTICAL POSITION HAS CHANGED
	CAME AC1,LECVP(DAT)	; IS THE OLD VERTICAL POSITION THE SAME AS THE PAGE PRINTER?
	PUSHJ P,DPEC		; NO, ERASE THE OLD CURSOR
	MOVE AC1,LELINE(DAT)	; PICK UP VERTICAL POSITION AGAIN
	CAMN AC1,CVP(DAT)	; IS IT THE SAME AS THE CURSOR POSITION?
	JRST DPTLE9		; YES, SEND OUT BOTH CURSORS
DPTLE8:	PUSHJ P,DPWPC		; NO, SEND OUT THE PAGE PRINTER'S
DPTL11:	PUSHJ P,DPWC		; SEND OUT THE LINE EDITOR CURSOR TOO
	JRST DPTLE4

DPTLE3:	PUSHJ P,DPEC		; ERASE THE CURSOR
	MOVE AC1,LELINE(DAT)	; PICK UP THE VERTICAL POSITION
	CAMN AC1,CVP(DAT)	; IS IT THE SAME AS THE CURSOR POSITION
	JRST DPTLE9		; YES, SEND THEM BOTH OUT
	PUSHJ P,DPWC		; WRITE OUT OUR CURSOR
	MOVE AC1,PPHPOS(DAT)	;GET PP CURSOR POS
	CAME AC1,LEHP(DAT)	; IS IT THE SAME AS THE CURRENT POSITION?
	PUSHJ P,DPWPC		; NO, WRITE OUT ANOTHER PAGE PRINTER CURSOR
	JRST DPTLE4		; YES, NO NEED TO WRITE A NEW ONE
;DPTLE4 DPTL12 DPTLE5 - EVERYBODY COMES HERE TO EXIT

DPTLE4:	SKIPN LETXC(DAT)	; HAS THE TEXT CHANGED?
	SKIPE LEMISS(DAT)	; OR DID I-LEVEL MISS DUE TO BUFFER INVALID?
DPTL12:	PUSHJ P,DPWT		; YES, QUEUE UP A TEXT REQUEST
DPTLE5:	MOVE AC1,LELINE(DAT)	; SAVE NEW STATE OF LINE EDITOR AND CURSORS
	MOVEM AC1,LEVP(DAT)
	MOVE AC1,PPHPOS(DAT)
	MOVEM AC1,LEHP(DAT)
	MOVE AC1,NCRS(DAT)	; NUMBER OF CRLFS IN LINE TOO
	MOVEM AC1,LENCRS(DAT)
	MOVE AC1,CVP(DAT)	; CURSOR VERTICAL POSITION
	MOVEM AC1,LECVP(DAT)
	SETZM LETXC(DAT)	; CLEAR THE FLAGS
	SETZM LEMISS(DAT)
	MOVE AC1,CHP(DAT)	; CURSOR HORIZONTAL POSITION
	MOVEM AC1,LECHP(DAT)
	ONSCN			;TURN ON SCANNER CHANNEL
	POPJ P,			; BYE NOW. Y'ALL HAVE A GOOD TIME!
;DPWT DPWT1 DPWT2

; THIS ROUTINE QUEUES UP A LINE EDITOR TEXT REQUEST

DPWT:
IFN FTDM,<
	TLNE UUO,DMLIN		; Use different routine for DM
	JRST DMLED
>;FTDM
	PUSH P,DDB
	PUSHJ P,GETQ		; GET A TASK BLOCK
	PUSH P,AC1		; SAVE ITS ADDRESS
	PUSHJ P,GETQ		; GET ANOTHER ONE
	MOVE AC2,(P)		; PICK UP ADDRESS OF FIRST ONE AGAIN
	MOVEI AC3,LEXFR		; CALL THE LINE EDITOR I-LEVEL ROUTINE
	HRRM AC3,(AC1)		; PUT IT IN THE DISPATCH ADDRESS OF EACH TASK BLOCK
	HRRM AC3,(AC2)
	MOVE AC3,LELINE(DAT)	; PICK UP VERTICAL POSITION OF LINE EDITOR BUFFER
	HRLM AC3,QLINE(AC1)	; START THE TRANSFER HERE
	HRLM AC3,QLINE(AC2)
	HRLM DAT,(AC1)		; PUT IN ADDRESS OF DPY PROGRAM HEADER
	HRLM DAT,(AC2)
	ADD AC3,NCRS(DAT)	; GET NUMBER OF LAST LINE OF TRANSFER
DPWT1:	HRRM AC3,QLINE(AC1)	; SET THAT AS LAST LINE
	HRRM AC3,QLINE(AC2)
	SETZM QFIELD(AC1)	; SEND OUT TASKS OUT ON OPPOSITE FIELDS
	SETOM QFIELD(AC2)
	HRLI DAT,DPLED		; MAKE UP A CLOCK REQUEST WORD
	MOVEM DAT,QWAKE(AC1)
	MOVEM DAT,QWAKE(AC2)
	SKIPN AC3,SC(UUO)	; IS THERE A COUNT WORD?
	JRST DPWT2		; NO, DON'T BOTHER
	AOS @SC(UUO)		; YES, BUMP IT TWICE
	AOS @SC(UUO)
DPWT2:	MOVEM AC3,QCOUNT(AC1)
	MOVEM AC3,QCOUNT(AC2)
	MOVEI DDB,(DAT)
	PUSHJ P,QBLOCK		; QUEUE UP THE FIRST ONE
	POP P,AC1		; GET THE ADDRESS OF THE SECOND ONE
	PUSHJ P,QBLOCK		; QUEUE IT UP TOO.
	POP P,DDB
	POPJ P,
;DPEOSL

; THIS ROUTINE ERASES THE OLD SECOND LINE OF THE LINE EDITOR

DPEOSL:
IFN FTDM,<
	TLNE UUO,DMLIN
	JRST DMEOSL		;Different routine for DM
>;FTDM
	PUSH P,DDB
	PUSHJ P,GETQ		; GET A TASK BLOCK
	PUSH P,AC1
	PUSHJ P,GETQ
	MOVE AC2,(P)
	PUSH P,AC3		;Save number of CRLFs now
	MOVEI AC3,ERASE
	HRRM AC3,(AC1)
	HRRM AC3,(AC2)
	MOVE AC3,LELINE(DAT)	; PICK UP VERTICAL POSITION
;	ADD AC3,NCRS(DAT)	; ADD IN LENGTH OF TRANSFER
	ADD AC3,(P)		; ADD IN LENGTH OF TRANSFER
	SUB P,[1,,1]
	ADDI AC3,1		; BUMP LINE NUMBER TO ONE PAST THE CURRENT LAST LINE
	HRLM AC3,QLINE(AC1)	; PUT THAT IN AS STARTING AND ENDING LINE
	HRLM AC3,QLINE(AC2)
	MOVE AC3,LEVP(DAT)	; PICK UP LAST VERTICAL POSITION
	ADD AC3,LENCRS(DAT)	; ADD IN LENGTH OF LAST TRANSFER
	HRLM UUO,(AC1)		; PUT IN ADDRESS OF PAGE PRINTER CONTROL BLOCK
	HRLM UUO,(AC2)
	JRST DPWT1
;DPEC DPEOPC DPEC1 DPEC2

; THIS ROUTINE ERASES THE OLD CURSOR

DPEC:	SKIPA AC2,LECVP(DAT)	;OLD POSITION
DPEOPC:	MOVE AC2,LEVP(DAT)	;SAME THING FOR PP CURSOR
	JUMPL AC2,CPOPJ		;WARN'T NONE
	PUSHJ P,GETQ
DPEC1:	HRLM AC2,QLINE(AC1)	; PUT THAT IN AS STARTING LINE
;	ADDI AC2,1		; BUMP IT BY ONE
	HRRM AC2,QLINE(AC1)	; FOR PESSIMISM
	SETOM QHPOS(AC1)	; CLEAR THE HORIZONTAL POSITION, INDICATING CURSOR ERASURE
DPEC2:	SETZM QFIELD(AC1)	; GOING OUT ON FIELD 1
	HRLI DAT,DPLED
	MOVEM DAT,QWAKE(AC1)	; WAKE UP THE LINE EDITOR DECISION TREE WHEN DONE
	MOVE AC3,SC(UUO)	; COUNT THROUGH OUR COUNTER TOO
	MOVEM AC3,QCOUNT(AC1)
	SKIPE SC(UUO)		; IS THERE A COUNT WORD?
	AOS @SC(UUO)		; YES, BUMP IT BY ONE
	HRLM UUO,(AC1)		; SAVE THE PAGE PRINTER CONTROL BLOCK ADDRESS
	MOVEI AC3,CURSOR	; USE THE CURSOR SUBROUTINE
	HRRM AC3,(AC1)
	PUSH P,DDB
	MOVE DDB,DAT
	PUSHJ P,QBLOCK		; QUEUE UP THE REQUEST
	POP P,DDB
	POPJ P,
;DPWPC DPWPC1 DPWPC2 DPWC DPWB

; THESE ROUTINES QUEUE UP THE VARIOUS COMBINATIONS OF CURSORS THAT MAY ARISE.

DPWPC:	PUSHJ P,GETQ		; GET A TASK BLOCK FOR THE PAGE PRINTER'S CURSOR
	MOVE AC2,LELINE(DAT)	; GET IT'S VERTICAL POSITION
	MOVE AC3,PPHPOS(DAT)
DPWPC1:	SETOM QHPOS(AC1)	; CLEAR OUT ONE OF THE HORIZONTAL POSITION WORDS
DPWPC2:	HRLM AC2,QLINE(AC1)	; STORE THE STARTING LINE NUMBER OF THE TRANSFER
;	ADDI AC2,1		; FOR SAFETY, MAKE IT LOOK LIKE IT IS TWO LINES LONG
	HRRM AC2,QLINE(AC1)	; AND STORE THAT AS THE DESTINATION LINE NUMBER
	HRLM AC3,QHPOS(AC1)	; STORE THE HORIZONTAL POSITION
	JRST DPEC2		; FINISH QUEUEING UP THE BLOCK

; THIS ROUTINE QUEUES UP A LINE EDITOR CURSOR ONLY.

DPWC:	PUSHJ P,GETQ		; GET A TASK BLOCK
	MOVE AC2,CVP(DAT)	; PICK UP THE CURSOR VERTICAL POSITION
	MOVE AC3,CHP(DAT)	; GET THE HORIZONTAL POSITION
	JRST DPWPC1		; LET THE ABOVE ROUTINE DO ALL THE WORK

; THIS ROUTINE QUEUES UP A TRANSFER WITH TWO CURSORS ON THE SAME LINE

DPWB:	PUSHJ P,GETQ
	MOVE AC2,LELINE(DAT)
	MOVE AC3,CHP(DAT)	; PICK UP THE LINE EDITOR CURSOR'S HORIZONTAL POSITION
	HRRM AC3,QHPOS(AC1)	; PUT IT IN AS ONE OF THE HORIZONTAL POSITIONS INVOLVED
	MOVE AC3,PPHPOS(DAT)	;GET PP CURSOR POS
	JRST DPWPC2		; USE IT TOO.
;QBLOCK QBLDBG REQBLK QBLK

;QBLOCK	  HERE IS THE MAGIC SCHEDULING QUEUE ROUTINE
; IT IS CALLED WITH THE ADDRESS OF A TASK BLOCK IN AC1. SAID BLOCK
; MUST HAVE QLINE AND QFIELD SET, BECAUSE THE BLOCK IS MERGED INTO
; THE QUEUE STRUCTURE IN THE RIGHT PLACE ON THE BASIS OF THOSE DATA.

;   ∃ BLOCKS CALLED "FRAMES".  EACH FRAME HAS A POINTER TO A LIST OF ONE OR
; MORE TASK BLOCKS, ALL OF WHICH HAVE THE SAME FIELD (EITHER EVEN OR ODD).
; THE TASK BLOCKS ARE LISTED IN ASCENDING ORDER OF LINE NUMBER. IN GENERAL,
; THE LIST OF FRAMES ALTERNATES BY FIELD PARITY, THE EXCEPTION BEING 
; "MISSING" FRAMES.  FRAME BLOCK FORMAT IS:
;
; 		XWD 0,<POINTER TO NEXT FRAME, OR 0>
;	QLINE:	BITS 0-19 INDICATE WHICH LINES ARE USED BY TASK BLOCKS
;		  IN THIS FRAME.  BITS 0,1,2 FOR LINES 1&2,3&4,5&6, ETC.
;	QFIELD:	SAME AS IN A TASK BLOCK, 0 OR -1 FOR EVEN OR ODD FIELD.
;	QHPOS:	NOT USED
;	QLINK:	XWD 0,<ADDRESS OF 1ST TASK BLOCK>

QBLOCK:	AOS NPPXFR(DDB)		;COUNT A PP TRANSFER IN PROGRESS
	MOVEI AC2,NPPXFR(DDB)
	TLOA AC2,(<SOS>)	;PREPARE TO COUNT DOWN PP TRANSFERS
QBLK:	MOVSI AC2,(<JFCL>)	;WHOQUE AND UPGQ ENTER HERE
	MOVEM AC2,QINSTR(AC1)	;SAVE INSTRUCTION TO EXECUTE ON DEQUEING
	HGMAC(32)
IFN FTDDBG,<
	CONI PI,LQBLPI
	MOVE AC2,LQBLPI
	TRNN AC2,77000		;IN PROG ON 1 THROUGH 6?
	JRST QBLDBG		;NO
	PUSHACS
	PUSHJ P,DISMES
	ASCIZ /DD LOSSAGE /
	PUSHJ P,DISFLU
	POPACS
	PUSHJ P,WDDTCA
QBLDBG:	MOVEM AC1,LQBLTB	;SAVE LAST TASK BLOCK QBLOCK CALLED WITH
	MOVE AC2,(P)
	MOVEM AC2,LQBLPP	;SAVE LAST TOP OF STACK
	MOVE AC2,DDSQ
	MOVEM AC2,LQBLSQ
>
	MOVEI AC2,10		; SET FOR 8 TIMES THROUGH
	MOVEM AC2,QTIME(AC1)	; BEFORE WE DECLARE IT A LOSING TRANSFER
REQBLK:	HRRZ AC2,(AC1)
	CAIL AC2,PPXFR
	CAILE AC2,PPSTAR
	JRST QBLERR
	HLRZ AC2,(AC1)
	CAML AC2,MEMSIZ
	CAMLE AC2,RMEMSIZ
	JUMPN AC2,QBLERR	; IF THERE IS SOMETHING THERE NOT IN FREE STORAGE, ERROR!
	SKIPN INTACT(PID)	; IS SOME WISEASS CALLING US AT USER INTERRUPT LEVEL?
	JRST QBLCLC		; NO, ALL IS WELL.
	HRLI AC1,QBLCLK		; YES, PUT IN A CLOCK REQUEST TO DO THIS TASK AT REAL CLOCK LEVEL
	JRST AC1CLK		;Plant clock request from AC1
;QBLCLK QBLCLC QBLGO

; HERE WE SEE IF THE TASK IS AN EASY OUTSIDER.
; IF IT IS NOT, WE MAKE UP A MASK FOR THE NUMBER OF
; LINES IT COVERS.

QBLCLK:	HRRZ AC1,DAT		; PICK UP THE TASK BLOCK ADDRESS
QBLCLC:	PUSH P,TAC		; SAVE THE WORLD
	PUSH P,TAC1
	PUSH P,DAT
	PUSH P,UCHN
	PUSH P,CHR
	HLRE DAT,QLINE(AC1)	; PICK UP STARTING POSITION
	HRRE UCHN,QLINE(AC1)	; AND THE ENDING LINE NUMBER
	JUMPLE UCHN,QOOB	; IF ENDING LINE IS OUT OF BOUNDS, THIS IS AN EASY OUTSIDER
	SKIPN DDOFF		; IF DD IS BEING MAINTAINED, PRETEND THE TRANSFER IS OUT OF BOUNDS
	CAILE DAT,=40		; OR IF STARTING LINE IS BELOW SCREEN . . .
	JRST QOOB		; IS AN EASY OUTSIDER
	CAIG DAT,(UCHN)		; IS THE STARTING LESS THAN THE FINISHING?
	AOJA UCHN,QBLGO		;CAN'T MAKE NEXT LINE
	PUSHACS
	PUSHJ P,DISMES
	ASCIZ /STARTING LINE LT FINISHING LINE AT QBLOCK
/
	POPACS
QBLGO:	SETZ TAC,		; HERE WE MAKE A 20-BIT MASK, IN BITS
	SETO TAC1,		;	0-19 OF TAC, WHERE EACH BIT
	ADDI DAT,1		;	REPRESENTS 2 LINES, AND IS ON
	ADDI UCHN,1		;	IF EITHER LINE IS TO BE WRITTEN
	LSH DAT,-1
	LSH UCHN,-1
	SUBM DAT,UCHN
IFN FTDDSTAT,<			;ONLY IF COUNTING STATISTICS
	ADDM	UCHN,NDDLCT	;COUNT  -(TOTAL NUMBER OF LINES QUEUED)
	AOS	NDDXCT		;COUNT TOTAL NUMBER OF TRANSFERS QUEUED.
	CAML	UCHN,[-2]
	AOS	NDDL1C		;COUNT 1 AND 2 LINE TRANSFERS.
>
	ROTC TAC,-1(UCHN)
	MOVN UCHN,DAT
	ROT TAC,1(UCHN)		; C(TAC) IS THE PROPER 20-BIT MASK
IFN FTDDBG,<
	MOVEM TAC,LQBLMS
>
;QBL1 CNXTFR QBL6 QBL7

; HERE WE SCAN THE QUEUE SYSTEM LOOKING FOR A FRAME WITH SOME FREE LINES

QBL1:	MOVE DAT,QFIELD(AC1)	; WE WILL ENTER THE TASK ON ITS FIELD
	MOVE AC3,QLINE(AC1)	; MERGE BY LINE NUMBER
	MOVEI AC2,1		; SET THE FIELD SAVED WORD TO DIFFERENT FROM ANY LEGAL FIELD
	MOVEM AC2,DDLFD
	SETZB AC2,DDLST		; NOTE THAT THERE IS NO LAST FRAME
	EXCH AC2,DDQUE		; PICK UP (SHUDDER!) THE ENTIRE QUEUE STRUCTURE
	JUMPE AC2,QBL3		; IF THERE ISN'T ANY, MAKE UP ONE FROM SCRATCH.
	MOVEM AC2,DDSQ		; IF THERE IS ONE, SAVE IT FIRST.
CNXTFR:	CAME DAT,QFIELD(AC2)	; IS THIS FRAME ON THE RIGHT FIELD?
	JRST QBL4		; NO, MOVE ON TO NEXT FRAME
	TDNE TAC,QLINE(AC2)	; YES, IS THERE ROOM ON THIS FRAME?
	JRST QBL8		; NO, GO ON TO NEXT FRAME
	ORM TAC,QLINE(AC2)	; YES, MARK OUR LINES AS CLAIMED
QBL6:	HRRZ CHR,QLINK(AC2)	; PICK UP ADDRESS OF TASK LIST FOR THIS FRAME
	JUMPE CHR,QBL7		; NONE THERE, ANNEX OUR TASK
	MOVE AC2,CHR		; SAVE THIS TASK BLOCK ADDRESS FOR ANNEXATION PURPOSES
	CAMLE AC3,QLINE(AC2)	; NOW, DO WE GO ABOVE THIS BLOCK?
	JRST QBL6		; NO, TRY NEXT BLOCK
	HRRM AC2,QLINK(AC1)	; YES, LINK US IN BETWEEN THESE TWO BLOCKS
	HLRZ AC3,QLINK(AC2)	; PICK UP POINTER TO PREVIOUS TASK
	HRLM AC3,QLINK(AC1)	; MAKE OUR BACKWARD LINK POINT TO THE LAST BLOCK
	HRRM AC1,QLINK(AC3)	; MAKE THE LAST BLOCK POINT TO US
	HRLM AC1,QLINK(AC2)	; MAKE THE NEXT BLOCK'S REVERSE POINTER POINT TO US
	JRST QBLXIT		; PUT THE QUEUE STRUCTURE BACK AND LEAVE

QBL7:	HRRM AC1,QLINK(AC2)	; ANNEX US BY PUTTING OUR ADDRESS IN THE LAST BLOCK'S FORWARD POINTER
	HRLZM AC2,QLINK(AC1)	; AND POINT OUR REVERSE POINTER TO HIM
	JRST QBLXIT
;QOOB GIVQB QBLERR WAKEQ WAKEQ1

; WE GET HERE IF THE TASK IS ENTIRELY OUT OF BOUNDS

QOOB:	XCT	QINSTR(AC1)	;UNWIND THE COUNT
	PUSHJ	P,WAKEQ		;WAKE UP ANYONE WAITING.
	POP	P,CHR		;RESTORE THE WORLD.
	POP	P,UCHN
	POP	P,DAT
	POP	P,TAC1
	POP	P,TAC
GIVQB:	JRST	GIVQ

; WE GET HERE IF EITHER THE DISPATCH ADDRESS OR THE DATA BLOCK ADDRESS
; IS ILLEGAL.

QBLERR:	PUSH P,(AC1)
	PUSHJ P,DISERR
	[ASCIZ /ILLEGAL TASK AT QBLOCK - /]
	DISARG OCT,<-1(P)>
	[ASCIZ /
/]
	-1
	SUB P,[XWD 1,1]
	XCT QINSTR(AC1)		; COUNT DOWN NPPXFR IF APPROPRIATE
	JRST GIVQ

WAKEQ:	SKIPE QCOUNT(AC1)	; IS THERE A COUNT HERE?
	SOSLE @QCOUNT(AC1)	; PERHAPS WE HAVE TO GO THROUGH THE WAKEUP RITUAL?
	POPJ P,			; NOT YET.
	SKIPN AC2,QWAKE(AC1)	; YES WE DO. PICK UP WAKEUP WORD
	POPJ P,
	TDNE AC2,[-100]		; IS IT A JOB NUMBER?
	JRST WAKEQ1		; NO, MUST BE A CLOCK REQUEST
	SKIPL JBTSTS(AC2)	; MAKE SURE HE IS STILL RUNABLE
	POPJ P,			; NO, LEAVE NOW
	MOVNI AC3,RUNQ		; PUT THAT JOB IN THE RUN QUEUE
	MOVEM AC3,JOBQUE(AC2)
	MOVEI AC3,QJOB(AC2)
	CONO PI,PIOFF
	SKIPE (AC3)
	JRST .+3
	EXCH AC3,QJOB
	HRROM AC3,@QJOB
	CONO PI,PION
	POPJ P,

WAKEQ1:	CONO PI,PIOFF		; STOP THE WORLD!
	IDPB AC2,CLKQ		; PUT IN THE CLOCK REQUEST
	CONO PI,PION
	POPJ P,
;QBL3 MAKFRM QBL4

; WE GET HERE WHEN THERE IS NO QUEUE AT ALL.

QBL3:	PUSHJ P,MAKFRM		; MAKE UP A NEW FRAME HEADER
	MOVEM AC1,DDSQ		; MAKE THIS THE NEW QUEUE
	JRST QBLXIT		; RESTORE ACCUMULATORS AND LEAVE.

; HERE IS A ROUTINE TO MAKE UP A NEW FRAME HEADER AND PUT THE CURRENT
; BLOCK IN IT AS ITS ONLY TASK.

MAKFRM:	PUSH P,AC1		; SAVE THE TASK BLOCK ADDRESS
IFN FTDDBG,<
	MOVEM AC1,LSMFTB
	MOVEM TAC,LSMFMS
	MOVEM DAT,LSMFFD
>
	AOS NDDFRM		; COUNT ONE MORE FRAME CREATION
	PUSHJ P,GETQ		; GET A BLOCK FOR THE FRAME HEADER
	SETZM (AC1)		; LINK IT TO NOWHERE FOR NOW.
	MOVEM TAC,QLINE(AC1)	; PUT IN OUR MASK AS THE INITIAL MASK FOR THE FRAME
	MOVEM DAT,QFIELD(AC1)	; STORE THE FIELD WORD AS THIS FRAME'S FIELD
	POP P,AC2		; GET BACK THE TASK BLOCK ADDRESS
	HRRZM AC2,QLINK(AC1)	; POINT THE FRAME HEADER TO US
	HRLZM AC1,QLINK(AC2)	; AND OUR BACKWARD POINTER TO THE FRAME HEADER
IFN FTDDBG,<
	MOVEM AC1,LSMFFM
>
	POPJ P,

; WE GET HERE IF THIS FRAME HAS THE WRONG FIELD

QBL4:	CAME DAT,DDLFD		; DOES THE LAST FRAME ALSO HAVE THE WRONG FIELD?
	SKIPN DDLST		; YES, DO WE EVEN HAVE A LAST FRAME?
	JRST QBL5		; NO TO EITHER, MOVE ON TO NEXT FRAME
	PUSH P,AC2		; SAVE POINTER TO CURRENT FRAME
	PUSHJ P,MAKFRM		; MAKE UP A BRAND NEW AND DIFFERENT FRAME
	MOVEM AC1,@DDLST	; INSERT IT BETWEEN THESE TWO
	POP P,(AC1)		; POINT IT TO THE SUCCESSOR
	JRST QBLXIT
;QBL8 QBL5 QBL9 QBLXIT DDQCHK DDQCH1 DDQCH4 DDQCE1,2,3 DDCKR1,2,3 DDCHER DDTSCH DDTSC1,2 DDTSE1,2,3,4

; HERE IS A ROUTINE THAT MOVES ON TO THE NEXT FRAME, IF THERE IS NO NEXT
; FRAME, IT MAKES UP A FRAME AND ANNEXES IT ONTO THE FRAME LIST.

QBL8:	MOVEM DAT,DDLFD		; SAVE THE FIELD OF THE FRAME
	JRST QBL9

QBL5:	SETCAM DAT,DDLFD	; SAVE THE FIELD OF THE FRAME (OPPOSITE FROM US)
QBL9:	HRRZM AC2,DDLST		; SAVE THE ADDRESS OF THE LAST FRAME
	HRRZ AC2,(AC2)		; PICK UP ADDRESS OF NEXT FRAME
	JUMPN AC2,CNXTFR	; IF THERE IS ONE, GO CHECK IT OUT.
	PUSHJ P,MAKFRM		; OTHERWISE, MAKE UP A NEW FRAME HEADER
	HRRZM AC1,@DDLST		; LINK US ON TO THE FRAME LIST
QBLXIT:
IFN FTDDBG,<	PUSHJ P,DDQCHK	>
	MOVE AC2,DDSQ		; ALL DONE, PUT THE TASK QUEUE BACK
	MOVEM AC2,DDQUE
	AOS NDDQUE		; MARK ONE MORE IN THE QUEUE
	POP P,CHR		; RESTORE THE ACCUMULATORS
	POP P,UCHN
	POP P,DAT
	POP P,TAC1
	POP P,TAC
	CONO PI,PIOFF		; STOP THE WORLD WHILE WE START UP THE DATA DISC
	SKIPN DDRUN		; IS THE DISK RUNNING?
	SETOM DDSTART		; NO, START IT UP NEXT TICK
	CONO PI,PION
	POPJ P,

IFN FTDDBG,<
;CHECK STATE OF DD QUEUE.  CALL BEFORE SETTING UP DDQUE FROM DDSQ
DDQCHK:	MOVEI DAT,DDSQ
DDQCH1:	SKIPN AC1,(DAT)
	POPJ P,
	CAMGE AC1,MEMSIZ
	JRST DDQCE3		;ADDRESS OUT OF BOUNDS
	MOVSI CHR,-1
	TDNN CHR,(AC1)
	TDNE CHR,QLINK(AC1)
	JRST DDQCE1		;EXTRANEOUS BITS ON IN FRAME
;reg	MOVEI CHR,77777
;	TDNE CHR,QLINE(AC1)
;	JRST DDQCE1		;EXTRANEOUS BITS IN QLINE
	SKIPE CHR,QFIELD(AC1)
	AOJN CHR,DDQCE2		;QFIELD NOT 0 OR -1
	HRRZ AC2,QLINK(AC1)	;POINTER TO TASK BLOCK
	JUMPE AC2,DDQCH4
	CAMGE AC2,MEMSIZ
	JRST DDQCE3
	PUSHJ P,DDTSCH		;CHECK LIST OF TASK BLOCKS
DDQCH4:	MOVE DAT,AC1
	JRST DDQCH1

DDQCE3:	JSP CHR,DDCHER
	PUSHJ P,DISMES
	ASCIZ /FRAME BLOCK OR TASK BLOCK ADDRESS OUT OF BOUNDS /
	JRST DDCKR1

DDQCE2:	JSP CHR,DDCHER
	PUSHJ P,DISMES
	ASCIZ /QFIELD NOT ZERO OR ONE /
	JRST DDCKR1

DDQCE1:	JSP CHR,DDCHER
	PUSHJ P,DISMES
	ASCIZ /EXTRANEOUS BITS ON /
DDCKR1:	PUSHJ P,DISMES
	ASCIZ /IN FRAME BLOCK AT /
	MOVE TAC,-17+AC1(P)
	PUSHJ P,DISLOC
	PUSHJ P,DISMES
	ASCIZ /
PREVIOUS FRAME BLOCK AT /
	MOVE TAC,-17+DAT(P)
	PUSHJ P,DISLOC
DDCKR3:	PUSHJ P,DISMES
	ASCIZ /
FIND A WIZARD OR TYPE POPJ 3,$X
/
	PUSHJ P,DISFLUSH
	POPACS			;SO WE DON'T HAVE TO LOOK HARD TO FIND THE AC'S
	PUSHJ P,DDTCALL	
	JRST DDQCH4		;MAYBE IT'S POSSIBLE TO CONTINUE

DDCHER:	PUSHACS
	PUSHJ P,DISMES
	ASCIZ /DATA DISK QUEUE INCONSISTENT
/
	JRST @-17+CHR(P)

;CHECK TASK LIST POINTED TO BY AC2 , AC1 POINTS TO FRAME IT COMES FROM
DDTSCH:	PUSH P,AC1
DDTSC2:	HRRZ CHR,(AC2)		;ADDRESS OF TASK ROUTINE
	CAIL CHR,DWPINI
	CAIL CHR,WHOINI
	JRST DDTSE4
	SKIPE CHR,QFIELD(AC2)
	AOJN CHR,DDTSE1		;QFIELD NOT 0 OR -1
	HLRZ CHR,QLINK(AC2)	;BACKWARDS LINK
	CAIE CHR,(AC1)
	JRST DDTSE2		;BACKWARDS LINK IS WRONG
	HRRZ AC1,AC2
	HRRZ AC2,QLINK(AC2)	;GET FORWARD LINK
	JUMPE AC2,DDTSC1	;END OF LIST
	CAMGE AC2,MEMSIZ
	JRST DDTSE3		;TASK LINK OUT OF BOUNDS
	JRST DDTSC2

DDTSC1:	POP P,AC1
	POPJ P,

DDTSE4:	JSP CHR,DDCHER
	PUSHJ P,DISMES
	ASCIZ /TASK ROUTINE ADDRESS OUT OF RANGE /
	JRST DDCKR2

DDTSE3:	JSP CHR,DDCHER
	PUSHJ P,DISMES
	ASCIZ /FORWARD LINK OUT OF BOUNDS /
	JRST DDCKR2

DDTSE2:	JSP CHR,DDCHER
	PUSHJ P,DISMES
	ASCIZ /BACKWARS LINK WRONG /
	JRST DDCKR2

DDTSE1:	JSP CHR,DDCHER
	PUSHJ P,DISMES
	ASCIZ /QFIELD NOT ZERO OR ONE /
DDCKR2:	PUSHJ P,DISMES
	ASCIZ /IN TASK BLOCK AT /
	MOVE TAC,-17+AC2(P)
	PUSHJ P,DISLOC
	PUSHJ P,DISMES
	ASCIZ /
PREVIOUS TASK BLOCK (MAYBE FRAME BLOCK) AT /
	MOVE TAC,-17+AC1(P)
	PUSHJ P,DISLOC
	JRST DDCKR3
>
;DDSTRT NEWFRM SCNLOP

; HERE LIES THE INCREDIBLE INTERRUPT-LEVEL ROUTINES!
; LET THE READER BEWARE.

↑DDSTRT:
	SETZM DDSTART
	SKIPN DDQUE		; IS THERE ANYTHING FOR US?
	JRST APRADD		; NO, LEAVE NOW
	SETOM DDRUN		; WE ARE NOW OFFICIALLY RUNNING.
	MOVEM TAC,DDSTAC	; SAVE THE ACCUMULATORS
	MOVEM AC1,DDSAC1
	MOVEM AC2,DDSAC2
	MOVEM AC3,DDSAC3
	MOVEM DAT,DDSDAT
	EXCH P,APRPDL(PID)	; GET US A PDL TOO
	MOVEI AC3,APRADD	; WE WILL RETURN TO APRINT WHEN WE ARE DONE
	MOVEM AC3,DDRET
	MOVE AC1,DDQUE		; REMOVE THE FIRST FRAME FROM THE QUEUE ENTIRELY
NEWFRM:	MOVE AC2,(AC1)		; PICK UP THE ADDRESS OF THE NEXT FRAME
	MOVEM AC2,DDQUE		; MAKE IT THE NEW QUEUE
	MOVEM AC1,DDCURQ	; SAVE THIS ADDRESS AS OUR CURRENT FRAME
	HRRZ TAC,QLINK(AC1)	; PICK UP THE ADDRESS OF THE FIRST TASK IN THE FRAME
SCNLOP:	HRRZ AC2,QLINK(TAC)	; PICK UP THE ADDRESS OF THE NEXT TASK
	MOVEM AC2,DDNXT		; SAVE IT FOR FUTURE REFERENCE
	HLRZ DAT,(TAC)		; PICK UP THE DATA BLOCK ADDRESS
	HRRZ AC3,(TAC)		; AND THE ROUTINE ADDRESS
	CAIL AC3,DWPINI
	CAIL AC3,WHOINI
	CAIA			;LET'S NOT JUMP TO CONTUSIONS
	JRST (AC3)		; JUMP OFF TO THE ROUTINE
	PUSH P,CHR		;IN CASE WE WANT TO LOOK AT CHR
	MOVEI DAT,DDCURQ
IFN FTDDBG,<	PUSHJ P,DDQCH1	>	;SHOULDN'T EVER RETURN
	PUSHJ P,DDTCALL
	JRST AUTOLOAD
;RESCAN DDEXIT

; ALL THE I-LEVEL ROUTINES RETURN TO HERE WHEN THEY ARE DONE

RESCAN:	SKIPE TAC,DDNXT		; IS THERE ANOTHER TASK IN THIS FRAME?
	JRST SCNLOP		; YES, SERVE IT NOW.
	HRRZ AC1,DDCURQ		; PICK UP THE FRAME HEAD WE WERE WORKING ON.
	HRRZ AC2,QLINK(AC1)	; SEE IF THERE ARE ANY TASKS LEFT ON IT.
	JUMPE AC2,DDEXIT	; NO, THEY MUST HAVE ALL SUCCEEDED
	HRLI AC2,DDREQ		; YES, PUT IN A CLOCK REQUEST TO REQUEUE THEM
	CONO PI,PIOFF		; THIS WAY, THEY WILL GET TRIED AGAIN
	IDPB AC2,CLKQ
	CONO PI,PION
DDEXIT:	PUSHJ P,GIVQ		; RELEASE THE FRAME HEADER
	SKIPE AC1,DDQUE		; SEE IF THERE IS ANOTHER FRAME
	JRST NEWFRM		; YES, DO IT.
	SETZM DDRUN		; NO, DIE QUIETLY
	CONO DDD,RESET		; CLEAR OUT THE BEAST
	MOVE TAC,DDSTAC		; RESTORE ALL OUR ACCUMULATORS
	MOVE AC1,DDSAC1
	MOVE AC2,DDSAC2
	MOVE AC3,DDSAC3
	MOVE DAT,DDSDAT
	EXCH P,APRPDL(PID)
	JSR DDRTN		; RETURN TO LOSER
;DDREQ DDREQ1 DDREQ2 DDREQ3

; THIS ROUTINE IS CALLED AT CLOCK LEVEL WITH A LIST OF TASKS THAT
; TIMED OUT OR LOST IN SOME OBSCURE WAY. WE JUST REQUEUE THEM AND
; TRY AGAIN.

DDREQ:	HRRZ AC1,DAT		; PICK UP THE TASK LIST
DDREQ1:	HRRZ DAT,QLINK(AC1)	; GET ADDRESS OF NEXT BLOCK ON LIST
	SOSG QTIME(AC1)		; HAVE WE TRIED TOO MANY TIMES
	JRST DDREQ2		; YES, DON'T REQUE IT.
	PUSHJ P,REQBLK		; REQUE THE TASK
DDREQ3:	JUMPE DAT,CPOPJ		; IF NO MORE TASKS, LEAVE
	MOVE AC1,DAT
	JRST DDREQ1

DDREQ2:	MOVE TAC,AC1
	PUSHJ P,DEQWAK		; WAKE UP CALLER
	JRST DDREQ3
;DEQ DEQWAK DEQ1 DEQ2 GIVQ

; THIS ROUTINE TAKES A TASK OUT OF THE QUEUE AND WAKES UP ANYONE IF
; IT IS SUPPOSED TO.

↑DEQ:	MOVE	AC2,QLINK(TAC)	;PICK UP ADDRESS OF SUCCESSOR
	TRNE	AC2,-1		;IS THERE ANYONE HOME?
	HLLM	AC2,QLINK(AC2)	;YES, MAKE REVERSE LINK OF SUCCESSOR POINT TO OUR PREDECESSOR
	MOVS	AC2,AC2		;SAME DEAL FOR OTHER SIDE
	TRNE	AC2,-1		;ANYONE HOME?
	HLRM	AC2,QLINK(AC2)	;MAKE FORWARD LINK OF PREDECESSOR POINT TO SUCCESSOR
DEQWAK:	XCT	QINSTR(TAC)	;COUNT DOWN PP TRANSFER COUNT IF APPROPRIATE
	SKIPE	QCOUNT(TAC)	;IS THERE A COUNT WORD SOMEWHERE?
	SOSLE	@QCOUNT(TAC)	;YES, COUNT IT DOWN.
	JRST	DEQ1		;NO COUNT OR COUNT NOT EXPIRED
	SKIPN	AC1,QWAKE(TAC)	;PICK UP WAKEUP WORD
	JRST	DEQ1		;IF NONE THERE, DON'T BOTHER
	CAIGE	AC1,JOBN	;IS IT A JOB NUMBER?
	JUMPG	AC1,DEQ2	;JUMP IF THIS IS A JOB NUMBER
	CONO	PI,PIOFF	;THIS MUST BE A CLOCK REQUEST.  PLANT IT.
	IDPB	AC1,CLKQ
	CONO	PI,PION
	JRST	DEQ1

DEQ2:	SKIPL	JBTSTS(AC1)
	JRST	DEQ1		;DON'T REQUE IF JOB ISN'T RUNNABLE
	HLRZ	AC2,(TAC)
	HRRE	AC2,PRGJMP(AC2)	;CHECK WAIT FLAG
	JUMPGE	AC2,DEQ1	;NOT WAITING FOR DPY.  DON'T REQUE.
	PUSH	P,J
	MOVE	J,AC1
	MOVNI	AC2,RUNQ	;PUT THIS JOB IN THE RUN QUEUE
	MOVEM	AC2,JOBQUE(J)
	PUSHJ	P,REQUE
	POP	P,J
	SKIPE	JOB		;IS THE NULL JOB RUNNING?
	JRST	DEQ1		;NO.
	CONO	PI,PIOFF	;YES.  GIVE CHANNEL 7 A BIG KICK - FLUSH THE NULL
	PUSHJ	P,STOP2		;JOB AND RUN US.  (STOP2 TURNS ON THE PI)
DEQ1:	MOVE	AC1,TAC		;AC1←TASK BLOCK ADDRESS FOR SFSGIV
GIVQ:	PUSHJ	P,SFSGIV
	DDFS
	POPJ	P,
;PPXFR

; PAGE PRINTER TRANSFERS

PPXFR:	SKIPLE AC1,HEDPTR(DAT)	;LET'S SEE IF THIS IS A LEGAL PP
	CAML AC1,RMEMSI
	JRST ILLPP		;GARBAGEY HEADER ADR
	HLRZ AC1,PRGNUM(AC1)
	LDB AC3,[241000,,DDCW(DAT)]
	CAIE AC1,(AC3)
	JRST ILLPP		;DD CHNL DOESN'T MATCH
	SETZM DDSAV(DAT)	; INITIALIZE THE SAVE WORD
	SKIPE PPINV(DAT)	; IS THE TEXT VALID?
	JRST PPXFR2		; NO, FLUSH THE TRANSFER
	PUSHJ P,POSLIN		; GET NUMBER OF FIRST LINE ON PAGE IN AC3
	HLRE AC1,QLINE(TAC)	; PICK UP FIRST LINE OF TRANSFER
	CAMG AC1,VPOS(DAT)	; IS FIRST LINE OF TRANSFER BELOW CURRENT SCREEN?
	CAMGE AC1,AC3		; OR ABOVE FIRST LINE OF SCREEN?
	JRST PPXFR2		; YES, ABORT TRANSFER
	HRRE AC1,QLINE(TAC)	; SAME FOR LAST LINE OF TRANSFER
	CAMG AC1,VPOS(DAT)
	CAMGE AC1,AC3
	JRST PPXFR2
	HLRE AC3,QLINE(TAC)	; PICK UP STARTING LINE NUMBER
	SKIPG AC3		; IF IT IS ABOVE SCREEN . . .
	MOVEI AC3,1		; USE TOP OF SCREEN AS FIRST LINE
	MOVEI AC1,-1(AC3)	; GET NORMALIZED LINE NUMBER
	PUSHJ P,GLNADR		; GET LINE ADDRESS FROM LINE NUMBER
	ADD AC2,[XWD DISJMP,1]	; BUMP PAST CRLF ON LAST LINE
	MOVSM AC2,DDCW+2(DAT)	; PLACE JUMP TO TEXT IN CODE
	IMULI AC1,=12
	SKIPE QFIELD(TAC)	; CHECK THE FIELD
	ORI AC1,1		; PUT IT OUT ON THE ODD FIELD THIS TIME
	DPB AC1,[POINT 4,DDCW+1(DAT),23]
	LSH AC1,-4
	DPB AC1,[POINT 5,DDCW+1(DAT),15]
	HRRE AC3,QLINE(TAC)	; PICK UP FINISHING LINE OF TRANSFER
	CAILE AC3,=40		; IS IT OFF THE SCREEN?
	MOVEI AC3,=40		; YES, USE THE LAST LINE ON THE SCREEN
	CAMN AC3,VPOS(DAT)	; IS THIS THE SAME AS THE VERTICAL POSITION OF THE PAGE PRINTER
	JRST PPXFR4		; YES, NO NEED TO SAVE ANY WORDS.
	ADDI AC3,1		; BUMP LINE POINTER BY ONE TO GET TO THE END OF THIS LINE
	PUSHJ P,GLNADR		; PICK UP THE ADDRESS OF THE END OF THAT LINE
	MOVE AC1,(AC2)		; PICK UP THE WORD AT THE END OF THE LINE
	MOVEM AC2,DDSPT(DAT)	; SAVE THE POINTER TO THE SAVED WORD.
	MOVEM AC1,DDSAV(DAT)	; STORE IT IN THE PAGE PRINTER CONTROL BLOCK
	MOVSI AC1,DDSAV(DAT)	; PICK UP ADDRESS OF SAVED WORD
	HRRI AC1,DISJMP		; PLACE A JUMP TO IT WHERE IT WAS IN THE BUFFER
	MOVEM AC1,(AC2)
;PPXFR1 PPXFR2 PPXFR3 PPXFR4 ILLPP

PPXFR3:	MOVEI AC1,DDCW(DAT)	; PICK UP ADDRESS OF START OF TRANSFER
	CONO DDD,USUAL		; SET UP THE DATA DISC
	DATAO DDD,AC1		; SEND OUT THE ADDRESS
	PUSHJ P,ISYNC		; WAIT FOR IT
	JFCL
	JRST PPXFR1		; LOSE BIG, LEAVE THE TRANSFER IN THE QUEUE
PPXFR2:	PUSHJ P,DEQ		; WIN, TAKE THE TASK OUT OF THE QUEUE
PPXFR1:	MOVSI AC1,040000	; CLEAR THE 'NO ERASE' BIT IF WE SET IT
	ANDCAM AC1,DDCW(DAT)
	SKIPE AC1,DDSAV(DAT)	; RESTORE THE SAVED WORD, IF THERE IS ANY
	MOVEM AC1,@DDSPT(DAT)
	JRST RESCAN

PPXFR4:	MOVSI AC1,040000	; IF WE ARE AT THE BOTTOM OF THE SCREEN,
	CAMN AC2,VPOS(DAT)	; THEN DON'T ERASE THE REST OF THE LINE
	ORM AC1,DDCW(DAT)	; BECAUSE WE MIGHT BE ERASING PART OF THE LINE EDITOR
	JRST PPXFR3		; THE LINE EDITOR WILL ERASE THE REST OF THE LINE ITSELF

ILLPP:	PUSHACS
	PUSHJ P,DISDAT
	PUSHJ P,DISMES
	ASCIZ /ILLEGAL PP AT PPXFR
/
	DEBCHE
	POPACS
	PUSHJ P,DEQ
	JRST RESCAN
;ERASE CWAIT

; HERE IS THE ERASE CODE.

ERASE:	HLRE AC2,QLINE(TAC)	; PICK UP STARTING ADDRESS
	SKIPG AC2		; IS IT ABOVE THE SCREEN?
	MOVEI AC1,1		; YES, START FROM LINE 1
	MOVEI AC1,-1(AC2)	; CONVERT IT TO HARDWARE FORM
	IMULI AC1,=12
	SKIPE QFIELD(TAC)	; WHAT FIELD DOES THIS GO OUT ON?
	ORI AC1,1		; ODD FIELD
	DPB AC1,[POINT 4,DDERRS+1,23]
	LSH AC1,-4
	DPB AC1,[POINT 5,DDERRS+1,15]
	MOVE AC1,DDCW(DAT)	; PICK UP FUNCTION SELECT
	MOVEM AC1,DDERRS	; USE IT FOR THE ERASURE
	HRRE AC1,QLINE(TAC)	; GET ENDING LINE NUMBER
	CAILE AC1,=40		; IF OFF THE BOTTOM OF THE SCREEN . . .
	MOVEI AC1,=40		; THEN USE THE NUMBER OF THE LAST LINE ON THE SCREEN
	SUB AC2,AC1		; GET THE NUMBER OF LINES TO BE ERASED
	ADD AC2,[XWD DISJMP,DDCRLF+=39]
	MOVSM AC2,DDERRS+2	; JUMP TO THE POSITION IN THE ERASURES THAT CORRESPONDS TO THAT MANY LINES.
	CONO DDD,USUAL
	DATAO DDD,[DDERRS]
CWAIT:	PUSHJ P,ISYNC
	JFCL
	JRST RESCAN		; LOSE BIG, JUST DO ANOTHER TASK
	PUSHJ P,DEQ		; WIN, TAKE US OUT OF THE QUEUE
	JRST RESCAN		; AND GO DO SOMETHING ELSE.
;CURSOR CDX CURS2 CURS1

; CURSOR TRANSFERS.

CURSOR:	MOVE AC1,[POINT 36,CURZWD-1,35]
	MOVEM AC1,CZPNT		; INITIALIZE LIST OF WORDS IN CURSOR CODE WE USED
	MOVE AC1,DDCW(DAT)	; PICK UP COMMAND WORD WITH FUNCTION SELECT IN IT
	TLO AC1,002000		; MAKE IT A GRAPHICS WORD
	MOVEM AC1,DDCURS	; AND USE IT AS OUR SELECT WORD
	HLRE AC1,QLINE(TAC)	; PICK UP LINE NUMBER OF TRANSFER
	JUMPLE AC1,CDX		; IF OUT OF BOUNDS, FORGET IT
	CAILE AC1,=40		; IS IT OFF THE BOTTOM OF THE SCREEN?
	JRST CDX		; YES, RESTORE CURSOR CODE AND LEAVE
	IMULI AC1,=12
	SUBI AC1,2		; BACK UP THE LINE TO BEFORE THE NEXT TEXT
	DPB AC1,[POINT 4,DDCURS+1,23]
	LSH AC1,-4
	DPB AC1,[POINT 5,DDCURS+1,15]
	HLRE AC1,QHPOS(TAC)	; PICK UP FIRST HORIZONTAL POSITION
	SKIPL AC1		; IS THERE ANY?
	PUSHJ P,CMAKE		; YES, MAKE UP CODE FOR IT
	HRRE AC1,QHPOS(TAC)	; PICK UP SECOND HORIZONTAL POSITION
	SKIPL AC1		; IS THERE ANY?
	PUSHJ P,CMAKE		; YES, COMPILE IT.
	CONO DDD,USUAL
	DATAO DDD,[DDCURS]
	PUSHJ P,ISYNC
	JFCL
	JRST CURS2		; UNFORGIVABLE LOSSAGE, TRY AGAIN LATER
CDX:	PUSHJ P,DEQ		; REMOVE US FROM THE QUEUE
CURS2:	HRRZ AC1,CZPNT		; PICK UP POINTER TO CURSOR CODE ADDRESSES
	MOVEI AC2,2		; PICK UP A BLANK GRAPHICS WORD
CURS1:	CAIGE AC1,CURZWD	; ARE WE BACK TO THE START YET?
	JRST RESCAN		; YES, GO BACK FOR ANOTHER TASK
	MOVEM AC2,@(AC1)	; NO, CLEAR OUT THIS CURSOR
	SOJA AC1,CURS1		; BACK UP FOR THE NEXT ONE, IF ANY.
;CMAKE CMAKE1 CMAKE2

; THIS ROUTINE MAKES UP THE CODE FOR A CURSOR.

CMAKE:	IMULI AC1,6		; CONVERT TO NUMBER OF BITS FROM LEFT MARGIN
	ADDI AC1,1		; THE UNIVERSAL FUDGE FACTOR STRIKES AGAIN!
	LDB AC2,[POINT 5,AC1,35]
	LSH AC1,-5		; IT IS NOW CONVERTED TO NUMBER OF WORDS AND BITS WITHIN LAST WORD
	ADDI AC1,DDCURS+2	; MAKE UP POINTER TO THE GRAPHICS WORD IN QUESTION
	IDPB AC1,CZPNT		; SAVE THIS ADDRESS SO WE CAN ZERO IT WHEN WE LEAVE
	PUSHJ P,CMAKE1		; SHIFT OVER A CURSOR
	MOVNS AC2
	LSH AC3,(AC2)
	ANDCMI AC3,17		; ZERO OUT POSSIBLE OVERFLOW INTO OPCODE
	ORM AC3,(AC1)		; PUT THOSE BITS INTO THE LOCATION WE CALCULATED
	CAMLE AC2,[-=26]	; IS THERE TWO WORDS WORTH?
	POPJ P,			; NO, RETURN NOW
	ADDI AC1,1		; YES, BUMP POINTER
	IDPB AC1,CZPNT		; AND SAVE IT
	PUSHJ P,CMAKE1		; MAKE UP ANOTHER CURSOR
	LSH AC3,=32(AC2)
	ORM AC3,(AC1)		; SET IT IN PLACE
	POPJ P,

;THIS SUBROUTINE REPLACES "MOVSI AC3,360000"
;ALSO "-=26" ABOVE USED TO BE "-=28", BUT OUR CURSOR IS BIGGER
CMAKE1:	SKIPN AC3,HEDPTR(DAT)	;UNWIND BACK TO TTY NUMBER
	JRST CMAKE2		;LOSE! (this thought to be a timing bug)
	HRRZ AC3,PRGNUM(AC3)	;MAKE FUNNY-LOOKING CURSOR IF IN INCHRW
	SKIPN AC3,TTYTAB(AC3)
	JRST CMAKE2		;I THINK THERE HAS TO BE A DDB BUT...
	MOVE AC3,DEVIOS(AC3)
	TLNE AC3,DDTM		;THIS BIT IS ON FOR INCHRW
	SKIPA AC3,[314000,,0]	;--  --
CMAKE2:	MOVSI AC3,360000	;----
	POPJ P,
;LEXFR LEXFR4

; LINE EDITOR TRANSFERS

LEXFR:	HRRZ AC1,CURPP(DAT)	; PICK UP PAGE PRINTER CONTROL BLOCK ADDRESS
	SKIPE PPNQT(AC1)	; IS THERE ANYTHING NOT COUNTED IN THE QUEUE
	JRST LEXFR2
	SKIPN PPENQ(AC1)	; IF ANYONE THERE, ABORT THE TRANSFER
	SKIPE LEINV(DAT)	; IS THE BUFFER VALID?
	JRST LEXFR2		; NO, SET 'MISSED IT' FLAG AND QUIT
	HLRE AC1,QLINE(TAC)	; PICK UP LINE NUMBER
	JUMPLE AC1,LEXFR1	; IF STARTING LINE IS ABOVE SCREEN, FORGET IT
	SUBI AC1,1		; OTHERWISE WE WILL SHOW AS MUCH AS WE CAN
	IMULI AC1,=12		; CONVERT TO DD FLAVOR LINE ADDRESS
	SKIPE QFIELD(TAC)	; WHAT FIELD DOES THIS TRANSFER WANT TO GO TO?
	ORI AC1,1		; ODD FIELD, MAKE LINE ADDRESS ODD
	DPB AC1,[POINT 4,LEBFR+1,23]
	LSH AC1,-4
	DPB AC1,[POINT 5,LEBFR+1,15]
	MOVE AC1,FCPOS(DAT)	; PICK UP NUMBER OF CHARACTERS IN BUFFER
	MOVE AC2,PRGNUM(DAT)	; GET DPY NUMBER
	SKIPL LETAB(AC2)	; IS THE LINE EDITOR INITIALIZED?
	SETZ AC1,		; NO, NO CHARACTERS IN IT
	JUMPN AC1,LEXFR3	; IF SOME CHARACTERS THERE, WE ARE SET.
	MOVE AC1,[ASCID /  
/]
	MOVEM AC1,LEBFR+2	; IF NONE, CLEAR OUT THE LINE WITH A SPACE AND A CRLF
LEXFR4:	MOVE AC1,CURPP(DAT)	; PICK UP ADDRESS OF PAGE PRINTER CONTROL BLOCK
	MOVE AC2,DDCW(AC1)	; GET FUNCTION SELECT WORD
	MOVEM AC2,LEBFR		; USE IT FOR US
	MOVEI AC2,2		;COLUMN OFFSET
	SKIPGE LEPOS(DAT)
	JRST .+3		;THAT'S THE POS IF LEYPOS IN EFFECT
	ADD AC2,DPHPOS(AC1)
	ADD AC2,LNLNGT(AC1)	;ELSE FOLLOW PP
	DPB AC2,[POINT 8,LEBFR+1,7]
	CONO DDD,USUAL		; START UP THE BEAST
	DATAO DDD,[LEBFR]	; AND AWAY WE GO . . .
	PUSHJ P,ISYNC
	JRST RESCAN
	JRST RESCAN
	JRST LEXFR1		; WIN, DEQUEUE US AND LEAVE
;LEXFR1 LEXFR2 LEXFR3

; WE GET HERE WHEN THE TRANSFER IS DONE OR ABORTED.

LEXFR2:	SETOM LEMISS(DAT)	; NOTE THAT WE MISSED THIS TRANSFER DUE TO BUFFER INVALID
LEXFR1:	MOVE DAT,CURPP(DAT)	; DEQ TAKES POINTER TO PP BLOCK IN DAT
	PUSHJ P,DEQ		; REMOVE US FROM THE QUEUE
	HRRZ AC3,LLW(DAT)	; PICK UP LAST LINE TRANSFERRED
	CAME AC3,VPOS(DAT)	; IS THE PAGE PRINTER UP TO DATE?
	SKIPE PPENQ(DAT)	; YES, IS IT BUSY NOW?
	JRST RESCAN		; UP TO DATE OR BUSY
	HRLI DAT,REFLINE	; NOT UP TO DATE AND NOT BUSY, REFRESH ITS LINE
	CONO PI,PIOFF		; PLANT A CLOCK REQUEST
	IDPB DAT,CLKQ
	CONO PI,PION
	JRST RESCAN

LEXFR3:	MOVEI AC1,LEBUF(DAT)	; GET THE ADDRESS OF THE LINE EDITOR TEXT
	HRLI AC1,DISJMP		; MAKE A JUMP TO IT
	MOVSM AC1,LEBFR+2	; AND PUT IT IN THE STARTUP CODE
	JRST LEXFR4
;WSE WHOWRT WHOWR1 WHOWR2 WHOWR3

; WHOLE SCREEN ERASURE AND AVAILABLE MESSAGE

WSE:	MOVE DAT,CURPP(DAT)	; PICK UP ADDRESS OF PAGE PRINTER CONTROL BLOCK
	MOVE AC2,DDCW(DAT)	; GET FUNCTION SELECT WORD
	MOVEI AC3,13		; MAKE IT INTO AN ERASE REQUEST
	MOVEM AC2,WSERC+1	; PUT DOWN NORMAL COPY FIRST
	TLNE AC2,(1B5)		; WHAT FLAVOR?
	ORI AC3,4
	DPB AC3,[POINT 8,AC2,7]
	MOVEM AC2,WSERC
	CONO DDD,USUAL
	DATAO DDD,[WSERC]
	JRST CWAIT		; GO WAIT FOR TRANSFER AND LEAVE


; HERE IS THE WHO LINE ROUTINE.

WHOWRT:	MOVE	AC1,QHPOS(TAC)	; PICK UP SAVED DPY NUMBER
	CAIE	AC1,DDAVLU	;AVAILABLE CHANNEL?
	JRST	WHOWR2		;NO
	MOVEI	DAT,AVLWHO	;GET PTR TO DD PROG
	MOVE	AC1,AVLVP	;GET DD CW TO RANDOM POSITION ON SCREEN
	JRST	WHOWR3

WHOWR2:	SKIPN	FRETAB(AC1)	; IS OUR FREE STORAGE STILL HERE?
	JRST	WHOWR1		; NO, EXIT NOW
	MOVE	AC1,[CW 3,2,4,0,5,0]
WHOWR3:	SKIPE	QFIELD(TAC)
	ORI	AC1,1B23
	MOVEM	AC1,1(DAT)	; PUT IT IN THE DD PROG
	MOVEI	AC1,3(DAT)	; PUT RETURN ADDRESS INTO SYSTEM WHO LINE DPY CODE
	HRLM	AC1,DDDRET
	CONO	DDD,USUAL
	DATAO	DDD,DAT
	PUSHJ	P,ISYNC
	JFCL
	JFCL
	MOVE	AC1,QHPOS(TAC)	; GET DPY NBR/AVL CODE BACK
	CAIE	AC1,DDAVLU	; ARE WE DOING THE AVL CHN?
	JRST	WHOWR1		; NO
	HRLZI	AC2,20000	; YES, TURN OFF ERASE BIT IN CW
	ANDCAM	AC2,(DAT)
WHOWR1:	PUSHJ	P,DEQ
	AOS	WHOPTR		;COUNT ANOTHER FIELD DONE.
	JRST	RESCAN
;POG POG0 POG1 POGCLK PPSTAR POGX1 POGX2  -  USER DATA DISC PROGRAM

POG:	PUSH	P,J
	HLRZ	AC1,QHPOS(TAC)		;RELATIVE ADR OF CELL TO SET FIELD
	SKIPE	AC1			;SKIP IF NONE
	PUSHJ	P,POGX1
	POP	P,J
	CONO	DDD,USUAL!EXECM
	MOVEI	AC1,PRGCW(DAT)		;ABSOLUTE ADDRESS OF START OF PROGRAM
	DATAO	DDD,AC1			;SEND IT OUT
	PUSHJ	P,ISYNC
	JFCL
	JFCL
	PUSH	P,J
	MOVE	J,QWAKE(TAC)
	SOS	JBTGLU(J)
IFN FTSTAT,<	PUSHJ P,GLUSTT	>
	HRRZ	AC2,QHPOS(TAC)		;ADR OF USER'S COUNT CELL
	SKIPE	AC2			;SKIP IF NONE.
	PUSHJ	P,POGX2			;DECREMENT USER'S COUNT CELL
	MOVE	AC2,PRGCNT(DAT)
	SOJG	AC2,POG0		;JUMP IF THIS IS NOT THE LAST TRANSFER

	CACHE	(CSHDD)

POG0:	POP	P,J
	SKIPN	DPRLSF(DAT)		;ARE WE A DETACHED JOB?
	JRST	POG1			;NO, LEAVE
	MOVE	AC2,PRGCNT(DAT)
	SOJG	AC2,POG1		;JUMP IF THIS IS NOT THE LAST TRANSFER
	MOVEI	AC1,(DAT)		;ADDRESS OF DPY PROGRAM HEADER TO GIVE BACK
	HRLI	AC1,POGCLK		;(RETURN IT AT CLOCK LEVEL)
	CONO	PI,PIOFF
	IDPB	AC1,CLKQ
	CONO	PI,PION
POG1:	PUSHJ	P,DEQ			;REMOVE THE TASK
	JRST	RESCAN

POGCLK:	HRRZ	AC1,DAT			;RETURN PROGRAM HEADER ITSELF
	PUSHJ	P,FSGIVE
	POPJ	P,			;PLEASE DON'T OPTIMIZE!

;ROUTINE TO PRINT 'PAGE PRINTER HOLDING' MESSAGE

PPSTAR:	MOVE	AC1,DDCW(DAT)
	MOVEM	AC1,DDSTRS
	MOVEI	AC1,0
	SKIPE	QFIELD(TAC)
	MOVEI	AC1,1			;SET LINE ADDRESS ODD
	DPB	AC1,[POINT 1,DDSTRS+1,23]
	CONO	DDD,USUAL
	DATAO	DDD,[DDSTRS]
	JRST	CWAIT

POGX1:	MOVE	J,QWAKE(TAC)		;STORE CORRECT FIELD FOR 2-FIELD XFER
	PUSHJ	P,MAPSET
	HLRZ	AC1,QHPOS(TAC)
	HRLI	AC1,140100		;MAKE BYTE PNTR TO FIELD BIT
	MOVE	AC2,QFIELD(TAC)
	XCTR	XDB,[DPB AC2,AC1]	;STORE FIELD
	POPJ	P,			;RETURN, RESTORING MAP

POGX2:	PUSHJ	P,MAPSET		;HERE TO DECREMENT USER'S COUNT CELL
	XCTR	XRW,[SOS (AC2)]
	POPJ	P,			;RETURN TO CALLER AFTER RESTORING MAP

;ISYNC DDINT DDINT2

; ALL TRANSFERS COME BACK TO HERE WHEN THEY ARE DONE OR TIMED OUT

ISYNC:	POP P,DDDSP		; SAVE RETURN ADDRESS
	MOVEI AC3,6		; TIMEOUT IF NO INTERRUPT IN 8 TIX
	MOVEM AC3,DDCNT		; STORE IN THE COUNT WORD
	MOVEM DAT,DDCUR		; SAVE CONTROL BLOCK ADDRESS
	MOVEM TAC,DDCURT	; SAVE TASK BLOCK ADDRESS TOO.
	MOVE DAT,DDSDAT		; RESTORE ACCUMULATORS
	MOVE AC1,DDSAC1
	MOVE AC2,DDSAC2
	MOVE AC3,DDSAC3
	MOVE TAC,DDSTAC
	EXCH P,APRPDL(PID)	; RESTORE THE PDL
	JSR DDRTN		; AND RETURN TO WHEREVER

↑DDINT:	SKIPN DDRUN
	JRST DDILL
	MOVEM AC3,DDSAC3	; SAVE ONE ACCUMULATOR
	MOVEI AC3,DDIXIT	; MAKE US RETURN THROUGH CH3 NEXT TIME OUT
	MOVEM AC3,DDRET		; SO WE CAN RE-ENABLE THE CHANNEL
	MOVE AC3,DDDSP		; PICK UP RETURN ADDRESS
	EXCH PID,APRID+P1PID	; PICK UP PROCESSOR IDENTIFICATION
	CONSZ 510,DDNXM
	JRST DDNX
	CONSO 510,LOSE		; DID DD MISS A WORD FROM MEMORY?
	JRST DDINT1		; NO, GO AHEAD
DDINT2:	CONO 510,RESET		; YES, STOP IT AMID-TRANSFER
	JRST DDCMR
;DDNX DDINT1 DDCMR DDCLK DDIXIT DDIXI1

; DATA DISC NON-EX MEM TYPEOUT, ACCUMULATOR SAVER, AND CLOCK TIMEOUT ROUTINES

DDNX:	EXCH P,APRPDL(PID)
	PUSHACS
	PUSHJ P,DISDATE
	PUSHJ P,DISERR
	[ASCIZ /DATA DISC NON-EX MEM
/]
	-1
	POPACS
	EXCH P,APRPDL(PID)
	JRST DDINT2


DDINT1:	ADDI AC3,2		; ALL OK, BUMP RETURN ADDRESS TO SUCCESS RETURN
DDCMR:	MOVEM DAT,DDSDAT	; SAVE THE REST OF THE ACCUMULATORS
	MOVEM TAC,DDSTAC
	MOVEM AC1,DDSAC1
	MOVEM AC2,DDSAC2
	EXCH P,APRPDL(PID)
	MOVE DAT,DDCUR		; PICK UP ADDRESS OF CONTROL BLOCK
	MOVE TAC,DDCURT		; PICK UP ADDRESS OF TASK BLOCK
	HRLOI AC2,377777	; SET COUNT TO MAXIMUM WHEN NO TRANSFER IN PROGRESS
	MOVEM AC2,DDCNT
	JRST (AC3)		; RETURN TO LOSER

↑DDCLK:	MOVEM AC3,DDSAC3	; STORE THIS ACCUMULATOR
	MOVEI AC3,APRADD	; MAKE US RETURN TO APRSER
	MOVEM AC3,DDRET		; NEXT TIME OUT
	MOVE AC3,DDDSP		; PICK UP RETURN ADDRESS
	ADDI AC3,1		; BUMP BY ONE TO NOTE THAT CLOCK TIMEOUT HAS HAPPENED
	CONO 510,RESET		; TIMED OUT, MUST BE HUNG. CLEAR IT OUT.
	JRST DDCMR

DDIXIT:	EXCH PID,APRID+P1PID	; RESTORE PID
DDIXI1:	JEN @DPYCHL		;DISMISS
;DDILL

; WE GET HERE IF WE GET AN INTERRUPT FROM THE DATA DISK AND
; OUR MAGIC FLAG INDICATES THAT NO TRANSFER WAS IN PROGRESS.

DDILL:	EXCH P,APRPDL+P1PID	; GET A PUSHDOWN LIST
	PUSHACS			; SAVE OUR ACCUMULATORS
	PUSHJ P,DISMES		; GIVE HARDWARE PEOPLE NASTY MESSAGE!
	ASCIZ/
UNEXPECTED DATA DISC INTERRUPT!!!
/
	CONO 510,RESET		; CLEAR ITS MIND
	POPACS			; RESTORE OUR ACCUMULATORS
	EXCH P,APRPDL+P1PID	; RESTORE P
	JRST DDIXI1
;DEFINITIONS FOR DATA DISC ALLOCATION

DDLNK←←<600,,DDTAB>	;LINK OUT
DDALST←←<60600,,DDTAB>	;ALLOC LIST (PERMANENT)
↑DDUSR←←<221000,,DDTAB>	;USER FLD
DDELNK←←40		;LIST TERMINATOR (ZERO IS LEGAL VAL)
DDCLST←←<600,,JB2SWP>	;LIST OF CHANNELS OWNED BY JOB
↑DDBADB←←400000		;BIT IN RH OF DDTAB ENTRY, MARKS BAD CHANNEL
			;SET BY "DET DDn" COMMAND, CHAN ASSIGNED ONLY IF NO OTHERS

DDGBIT←←100		;"GET" BIT IN UUO
DDSBIT←←200		;"STATUS" BIT IN UUO
DDGMOD←←50300		;WHOLE MODE FLD
↑DDANYW←←200000		;LET ANYONE WRITE
DDSMSK←←600000		;MASK FOR USER SETTABLE BITS
DDUSR2←←222000		;TO SET USER & CLEAR EXTRA BITS

;SPECIAL USER CODES

↑DDAVLU←←200		;AVAILABLE CHANNEL
↑DDDETU←←201		;DETACHED FROM SYS (NO LONGER USED--BH 5/23/75)

;DEFINITIONS FOR VIDEO SWITCH ROUTINES

VDOP←←330300		;OPCODE FLD FOR UUO
VDPERM←←400000		;"PERMANENT" BIT - MUST BE SIGN
VDABSO←←200000		;"ABSOLUTE" BIT - AFFECTS JUST GIVEN LINE DESPITE MAPPING
VDXBIT←←400		;"EXTRA CHANNEL" BIT
;DDINI DDINI1 DDINI2 DDAVST DDLIST VDSYNC

;INITIALIZATION FOR DATA DISC ALLOCATION AND VIDEO SWITCH
DDINI:	SETOM DDTAB
	MOVE TAC,[DDTAB,,DDTAB+1]
	BLT TAC,DDTAB+DDELNK		;CLEAR TABLE FOR DUPLICATION TEST
	MOVE TAC,[440600,,DDLIST]
	MOVEI AC2,DDELNK
DDINI1:	ILDB AC1,TAC
	SKIPL DDTAB(AC1)
	JRST 4,.		;OOPS - WE'VE BEEN HERE BEFORE
	MOVEM AC2,DDTAB(AC1)	;INITIALIZE DDTAB WITH ALLOC LIST & FREE LIST
	DPB AC1,[DDALST(AC2)]
	MOVEI AC2,(AC1)
	CAIE AC1,DDELNK
	JRST DDINI1
	MOVEI J,JOBN-1
	MOVEI TAC,
	DPB TAC,[DDCLST(J)]	;INIT JOB CHNL LISTS
	SOJG J,.-1
	MOVEI TAC,40
	MOVEM TAC,DDFCNT	;INIT FREE CHNL COUNT
	MOVSI TAC,200
	HRR TAC,AVLCHN
	PUSHJ P,DDCGET		;GET CHN FOR AVAIL MSG
	JRST 4,.
	MOVEI AC1,(TAC)
	PUSHJ P,VDBIT
	MOVEM AC3,AVLBIT
	MOVSI AC1,-DDNUM
DDINI2:	MOVEI AC2,DDL0(AC1)
	MOVEM AC2,VDTIE(AC1)	;MAP EVERYONE TO MSG
	MOVEM AC3,VDPRM(AC1)
	CONO VDS,DPYNUM(AC1)
	DATAO VDS,AC3
	AOBJN AC1,DDINI2
	DPB TAC,[POINT 8,AVLWHO,15]
	PUSHJ P,WHOSYS		;INITIALIZE SYSTEM WHOLINE
	SETOM WHOKLU		;THIS MAKES WHOSER PUT THE MSG OUT
	POPJ P,

;PDP-6 HERE (FROM WHOSER) TO COMPUTE THE DD AVAILABLE MESSAGE

LOSYS


↑DDAVST:
	MOVEI AC2,1
	SKIPN DDFCNT		;ARE THERE ANY CHANNELS FREE?
	MOVE AC2,[DDUNMS,,DISJMP]	;NO MAKE UNAVAIL MESSAGE HAPPEN
	SKIPN MAINTMODE
	SKIPE TTYLOK
	MOVE AC2,[XWD DDDMES,DISJMP]
	MOVEM AC2,DDWMES

	DATAI DSK,AC1		;CHOOSE A (RANDOM) NUMBER, ANY NUMBER
	ADD AC1,TIME
	IDIVI AC1,300
	ADDI AC2,10
	MOVEI AC1,(AC2)
	DPB AC2,[150300,,AVLVP]	;STORE LOW ORDER PART
	LSH AC2,-3		;REMOVE LOW ORDER PART
	DPB AC2,[240500,,AVLVP]	;STORE HI PART
	IDIVI AC1,=6		;CONVERT RASTER LINE TO TEXT LINE (LOW-ORDER BIT NOT HERE)
	HRLI AC1,3(AC1)		;AVL MSG USES 4 DIFFERENT TEXT LINES
	MOVSM AC1,AVLLN
	MOVSI AC2,20000
	IORM AC2,AVLWHO	;TURN ON ERASE BIT TO FORCE ERASE BEFORE FIRST FIELD
	POPJ P,

DDLIST:	BYTE (6)37,36,35,34,33,32,31,30,27,25,24,23,3,15,7,22,11,12
	BYTE (6)26,5,13,17,2,14,10,1,20,21,16,6,4,0,DDELNK

↑VDSYNC:0↔11↔12↔13↔14↔15↔16↔7

HISYS
;DDCHAN DDCDSP DDAREL DDARL1

;ALL-PURPOSE DD CHANNEL DIDDLING UUO:
;AC31-35 = CHAN, AC30 => NO SPECIFIC CHAN (CONSOLE CHAN FOR STATUS)
;AC28-29: 0-RELEASE, 1-GET, 2-GET STATUS, 3-SET STATUS
;AC29=1 => FAILURE POSSIBLE, SKIP ON SUCCESS
;AC0 PRIVATE CHAN, SET ON GET OR SET STATUS
;REST OF LH READ-ONLY STATUS BITS, RETURNED ON SINGLE-CHAN OPS OR GETTING CHAN:
;AC10-17 USE: 0=FREE, 1-77=JOB N, 100-177=TTY N-100+DDL0, 200-377 SPECIAL

↑DDCHAN:DPB J,[DDUSR2,,TAC]
	LDB AC1,[DDGMOD,,TAC]
	ANDCMI TAC,-40
	PUSHJ P,@DDCDSP(AC1)
	JRST STOTAC
	AOS (P)
	JRST STOTAC

DDCDSP:	DDCREL
	DDAREL
	DDCGET
	DDAGET
	DDSGET
	DDCSGT
	DDSSET
	DDCSST

;RELEASE ALL CHANS OWNED BY JOB (ALSO CALLED ON RESET)

↑DDAREL:PUSH P,TAC
	LDB TAC,[DDCLST(J)]
	SOJL TAC,TPOPJ
	HLL TAC,(P)
	MOVEI AC1,
	DPB AC1,[DDCLST(J)]	;CLEAR THE LIST HERE IN ONE SWELL FOOP
DDARL1:	LDB AC3,[DDLNK(TAC)]
	PUSHJ P,DDREL		;SO WE DON'T HAVE TO DO IT HERE
	HRRI TAC,(AC3)
	CAIE AC3,DDELNK
	JRST DDARL1
	JRST TPOPJ
;DDCREL DDCRL1 DDREL SCNONJ DDREL2

;RELEASE CHANNEL C(TAC)

DDCREL:	LDB AC2,[DDLNK(TAC)]	;HERE CHAN BELONGS TO JOB
	LDB AC1,[DDCLST(J)]	;& MUST BE DELINKED FROM JOB'S LIST
	CAIN AC1,1(TAC)
	AOJA AC2,[CAIL AC2,41
		MOVEI AC2,
		DPB AC2,[DDCLST(J)]
		JRST DDREL]
	SOJL AC1,DDREL
DDCRL1:	LDB AC3,[DDLNK(AC1)]
	CAIN AC3,(TAC)
	JRST [DPB AC2,[DDLNK(AC1)]↔JRST DDREL]
	MOVEI AC1,(AC3)
	CAIE AC1,DDELNK
	JRST DDCRL1
↑DDREL:	LDB AC1,[DDUSR(TAC)]	;ENTER TO JUST RELEASE CHANNEL
	TSC AC1,TAC
	TRNE AC1,377
	JRST DDREL2		;DOESN'T BELONG TO HIM
	MOVEI AC1,(TAC)
	AOS AC2,DDFCNT
	CAIN AC2,1
	SETOM WHOKLU		;CHANGE TO AVAILABLE MESSAGE
	MOVSI AC2,377
	OFFSCN			;TURN OFF SCANNER CHANNEL
	LDB AC1,[DDALST(AC1)]
	TDNE AC2,DDTAB(AC1)	;SCAN UP ALLOC LIST (ORDERED)
	JRST .-2
	LDB AC2,[DDLNK(AC1)]	;SO WE CAN PUT IN RIGHT PLACE IN FREE LIST
	DPB TAC,[DDLNK(AC1)]
	DPB AC2,[DDLNK(TAC)]
	HRRZS DDTAB(TAC)
↑SCNONJ:
	ONSCN			;TURN ON SCANNER CHANNEL
	POPJ P,

DDREL2:	TLNN TAC,300
	POPJ P,			;JUST SOME LOSER
	PUSHACS
	PUSHJ P,DISERR
	[ASCIZ /ILLEGAL DD RELEASE - TAC=/]
	DISARG OCT,<TAC-20(P)>
	[ASCIZ /
/]
	-1
	POPACS
	POPJ P,
;DDCGET DDAGE1 DDCG1 DDAGE3 DDAGET DDAGE2 DDGET2 DDGET3

;GET CHAN SPECIFIED BY TAC(31-35) IF FREE

↑DDCGET:HLLZ AC3,TAC
	MOVEI AC1,(TAC)
	MOVSI AC2,377
	OFFSCN			;TURN OFF SCANNER CHANNEL
	TDNN AC2,DDTAB(AC1)
	JRST DDCG1
	ONSCN			;TURN ON SCANNER CHANNEL
	HLL TAC,DDTAB(AC1)	;TELL HIM HOW HE LOST
	POPJ P,

;ENTER HERE FROM DDAGET IF FIRST FREE CHANNEL IS MARKED BAD - BH 5/23/75
DDAGE1:	LDB AC1,[DDLNK(AC1)]	;LOOK THROUGH FREE LIST FOR A GOOD CHANNEL
	CAIN AC1,DDELNK		;END OF LIST?
	JRST DDAGE3		;YUP, NO GOOD CHANNELS, GET THE BAD ONE
	TDNE AC2,DDTAB(AC1)	;AC2 HAS THE BAD CHANNEL BIT
	JRST DDAGE1		;KEEP LOOKING, THIS ONE BAD TOO
	MOVSI AC2,377		;GOT ONE, SET UP FOR DDCG1
	HRRI TAC,(AC1)
DDCG1:	LDB AC1,[DDALST(AC1)]	;IT'S FREE - SCAN FOR GUY POINTING TO IT
	TDNE AC2,DDTAB(AC1)
	JRST DDCG1
	IORM AC3,DDTAB(TAC)
	LDB AC3,[DDLNK(TAC)]	;SO WE CAN LINK IT OUT
	DPB AC3,[DDLNK(AC1)]
	ONSCN			;TURN ON SCANNER CHANNEL
	MOVEI AC1,(TAC)
	JRST DDGET2

DDAGE3:	MOVE AC1,DDFLST		;HERE IF ONLY BAD CHANS AVAILABLE
	JRST DDAGE2		;SO WE PUNT BACK INTO DDAGET

;GET ANY FREE CHAN

DDAGET:	HLLZ AC3,TAC
	OFFSCN			;TURN OFF SCANNER CHANNEL
	MOVE AC1,DDFLST
	CAIN AC1,DDELNK
	JRST SCNONJ		;Turn scanner channel back on and POPJ
	MOVEI AC2,DDBADB	;GET BAD CHANNEL BIT (BH 5/22/75)
	TDNE AC2,DDTAB(AC1)	;IS FIRST FREE CHAN BAD?
	JRST DDAGE1		;YES, TRY FOR A BETTER ONE
DDAGE2:	LDB AC2,[DDLNK(AC1)]
	MOVEM AC2,DDFLST
	IORM AC3,DDTAB(AC1)
	ONSCN			;TURN ON SCANNER CHANNEL
	HRRI TAC,(AC1)
;COMMON CODE FOR BOTH FLAVORS OF GET. PUTS IN LIST IF GETTING FOR JOB.
;SETS AND ENFORCES PRIVACY BIT.
DDGET2:	SOSG DDFCNT
	SETOM WHOKLU			;SET NO CHANNELS LEFT MESSAGE
	TLNN TAC,300
	AOJA AC1,[LDB AC2,[DDCLST(J)]	;JOB - ADD TO ITS LIST
		DPB AC1,[DDCLST(J)]
		SOJGE AC2,[SOJA AC1,DDGET3]
		SOJA AC1,.+1]
	MOVEI AC2,DDELNK
DDGET3:	DPB AC2,[DDLNK(AC1)]
	AOS (P)
	JUMPGE TAC,CPOPJ	;THAT'S ALL IF HE'S NOT PARANOID
	MOVEI AC1,(TAC)		;ELSE FALL THRU
;DDFLSH DDFLS0 DDFL01 DDFLS1 DDFLS2 DDFLS3 DDFLS4 DDFLS9 DDFLSX DDCHEK DDCSGT DDSGET DDCFND

;ROUTINE TO THROW ALL SPIES OFF PRIVATE CHANNEL.
;CLOBBERS UCHN, AND THROWS MAPPERS OFF ALSO --BH 12/8/74

↑DDFLSH:PUSHJ P,VDBIT
	PUSH P,TAC
	PUSH P,TAC1
	LDB TAC1,[DDUSR(AC1)]
	CAIGE TAC1,100		;BH 12/8/74 IF CHAN IS IN USE AS TTY
	TDZA UCHN,UCHN		;BH (200+ SPECIALS DON'T COME HERE)
	MOVEI UCHN,DDL0-100(TAC1)	;BH THEN UCHN IS LINE #
	MOVSI TAC,-DDNUM+DPYNUM	;INCLUDE "SHADOW" CHANNELS HERE
DDFLS0:	TDNE AC3,VDMAP(TAC)	;HERE WE SCAN THE UNTIED MAPS
	CAIN TAC1,100(TAC)
	JRST DDFL01
	ANDCAM AC3,VDMAP(TAC)
	PUSHJ P,VDOUT1
DDFL01:	TDNE AC3,VDPRM(TAC)	;  AND THE PERM MAPS
	CAIN TAC1,100(TAC)
	JRST DDFLS3
	PUSHJ P,VDSTR1
	 ANDCAM AC3,VDTMP(AC2)
DDFLS3:	AOBJN TAC,DDFLS0
DDFLS1:	MOVSI TAC,-DDNUM
DDFLS2:	SKIPE AC2,LETAB+DDL0(TAC)	;HERE WE SCAN THE TEMP MAPS
	CAIN TAC1,100(TAC)
	JRST DDFLS4
	TDNN AC3,VDTMP(AC2)
	JRST DDFLS4
	ANDCAM AC3,VDTMP(AC2)
	PUSHJ P,VDOUTP
DDFLS4:	JUMPE UCHN,DDFLS9	;BH IF CHAN IS USED AS TTY, ALSO CHECK KBD MAP
	LDB AC2,[POINT 7,LINTAB+DDL0(TAC),35]	;BH WHAT HE'S MAPPED TO
	CAIN AC2,(UCHN)		;BH IF NOT MAPPED TO HERE
	CAIN AC2,DDL0(TAC)	;BH OR IF IT'S THE SAME TTY
	JRST DDFLS7		;BH THEN IGNORE
	MOVEI AC2,DDL0(TAC)	;BH ELSE GET HIS OWN LINE NUMBER
	DPB AC2,[POINT 7,LINTAB+DDL0(TAC),35]	;BH AND MAP HIM BACK
	JRST DDFLS8		;9/21/75 TIE HIM TO HIMSELF TOO
DDFLS7:	CAMN UCHN,VDTIE(TAC)	;9/21/75 ALSO TIE TO SELF IF TIED BUT NOT MAP HERE
	CAIN UCHN,DDL0(TAC)
	JRST DDFLS9
	MOVEI AC2,DDL0(TAC)
DDFLS8:	MOVEM AC2,VDTIE(TAC)
	PUSHJ P,VDOUT1		;9/21/75 REALLY GRONK THE VIDEO SWITCH
DDFLS9:	AOBJN TAC,DDFLS2
DDFLSX:	POP P,TAC1
	JRST TPOPJ

;SEE IF THIS GUY CAN HACK THIS DD CHAN (AC1)
;0 SKIPS FREE. 1 SKIP LOSE. 2 SKIPS HE'S GOT IT.
DDCHEK:	LDB AC2,[DDUSR(AC1)]
	JUMPE AC2,CPOPJ
	AOS (P)
	HRRE AC3,JBTLIN(J)
	JRST VDCCK0

;GET STATUS & # OF CONSOLE CHAN, AC UNCHANGED IF NONE (NOT DD)
DDCSGT:	PUSHJ P,DDCFND
	POPJ P,
			;FALL THRU

;GET STATUS OF CHAN TAC(31-35)
DDSGET:	HLL TAC,DDTAB(TAC)
	POPJ P,

;FIND CONSOLE CHAN FOR JOB

DDCFND:	MOVE AC1,JBTLIN(J)
	TLNN AC1,DDDLIN
	POPJ P,
	JUMPL AC1,CPOPJ		;DETACHED
	HRRZ AC1,LETAB(AC1)
	HLR TAC,PRGNUM(AC1)	;PRETEND HE USED HIS CHAN AS ARG (PRESERVE LH)
	JRST CPOPJ1
;DDCSST DDSSET VDBIT VDSTR1 VDSTRU VDSTR2 VDOUT VDOUT1 VDOUT2 VDOUT3 VDOUTP VDOUP0 VDOUP1 VDOUP2

;SET STATUS OF CONSOLE CHANNEL

DDCSST:	PUSHJ P,DDCFND
	POPJ P,
			;FALL THRU

;HERE HE CAN SET THE STATUS OF A CHANNEL IF IT'S HIS

DDSSET:	MOVEI AC1,(TAC)
	PUSHJ P,DDCHEK
	POPJ P,
	POPJ P,
	MOVE AC2,DDTAB(AC1)
	MOVSI AC3,DDSMSK
	OFFSCN			;TURN OFF SCANNER CHANNEL
	ANDCAM AC3,DDTAB(AC1)
	AND AC3,TAC
	IORB AC3,DDTAB(AC1)
	HLL TAC,AC3
	ONSCN			;TURN ON SCANNER CHANNEL
	JUMPGE TAC,CPOPJ1
	JUMPL AC2,CPOPJ1
	AOS (P)
	JRST DDFLSH		;TURNING PRIVATE - FLUSH LOSERS

;MAKES UP BIT (AC3) FROM DD CHAN (AC1)
↑VDBIT:	MOVNI AC2,(AC1)
	MOVSI AC3,400000
	LSH AC3,(AC2)
	POPJ P,

;THIS ROUTINE UPDATES BOTH PERMANENT & TEMPORARY (IF EXISTENT) MAPS
;WITH INTS OFF TO AVOID INCONSISTENT STATES
;TAC=CONSOLE #, @(P) IS DIDDLE INSTRUCTION
VDSTR1:	MOVEI AC2,VDPRM-VDTMP(TAC)
	OFFSCN			;TURN OFF SCANNER CHANNEL
	XCT @(P)
	SKIPE AC2,LETAB+DDL0(TAC)
	XCT @(P)
	ONSCN			;TURN ON SCANNER CHANNEL
	JRST VDOUP0

;SET EITHER TEMPORARY OR PERMANENT MAPPING, DETERMINED BY
;SIGN BIT OF DSER (CALLED FROM VDSMAP ROUTINES)

VDSTRU:	TLNE DSER,VDABSO!VDXBIT
	JRST VDSTU1		;DO TO VDMAP IF ABSOLUTE
	JUMPL DSER,VDSTR1
	SKIPN AC2,LETAB+DDL0(TAC)
	JRST CPOPJ1
	XCT @(P)
	MOVSI AC3,400000
	IORM AC3,LETBPT(AC2)	;INDICATE TEMP MAP IN EFFECT
	JRST VDOUP0

VDSTU1:	OFFSCN			;TURN OFF SCANNER CHANNEL
	TLNE DSER,VDXBIT
	JRST VDSTU2
	MOVEI AC1,0		;THIS WILL BE VDTIE ENTRY
	JUMPL DSER,.+2		;IF TEMPORARY,
	MOVSI AC1,400000	;  SET FLAG IN VDTIE
	PUSHJ P,VDESAD
VDSTU2:	MOVEI AC2,VDMAP-VDTMP(TAC)
	XCT @(P)
	TLNN DSER,VDXBIT
	MOVEM AC1,VDTIE(TAC)
	ONSCN			;TURN ON SCANNER CHANNEL
	AOS (P)			;DROPS INTO VDOUT

;OUTPUTS CURRENT MAPPING (TEMPORARY, IF EXISTENT, ELSE PERMANENT)
;FOR CONSOLE C(TAC)
↑VDOUT:	JUMPL TAC,CPOPJ		;NO III'S HERE
VDOUT1:	HRRZ AC2,VDTIE(TAC)
	JUMPE AC2,VDOUT2
	SKIPE LETAB(AC2)
	SKIPA AC2,LETAB(AC2)
	SKIPA AC2,VDPRM-DDL0(AC2)
	MOVE AC2,VDTMP(AC2)
VDOUT3:	OFFSCN			;TURN OFF SCANNER CHANNEL
	CONO VDS,DPYNUM(TAC)	;THIS WRAPS AROUND TO "SHADOW" WITH TAC>DDNUM
	DATAO VDS,AC2
	ONSCN			;TURN ON SCANNER CHANNEL
	POPJ P,

VDOUT2:	MOVE AC2,VDMAP(TAC)
	JRST VDOUT3

VDOUP0:	AOS (P)
↑VDOUTP:PUSH P,AC1		;PROPAGATE TO ALL MAPPERS
	PUSH P,AC3
	MOVEI AC3,DDL0(TAC)
	MOVSI AC1,-DDNUM
	SKIPN AC2,LETAB+DDL0(TAC)
	SKIPA AC2,VDPRM(TAC)
	MOVE AC2,VDTMP(AC2)
VDOUP1:	CAME AC3,VDTIE(AC1)
	JRST VDOUP2
	OFFSCN			;TURN OFF SCANNER CHANNEL
	CONO VDS,DPYNUM(AC1)
	DATAO VDS,AC2
	ONSCN			;TURN ON SCANNER CHANNEL
VDOUP2:	AOBJN AC1,VDOUP1
	POP P,AC3
	POP P,AC1
	POPJ P,
;VDSMAP VDMAP1 VDMP1A

;ALL-PURPOSE VDS DIDDLING UUO:  VDSMAP
;RH(AC)=ADR
;AC11-17 = TTY#, 0 => OWN CONSOLE; AC9=1 => USE "SHADOW" CHAN INDICATED BY AC11-17
;AC0=1 => PERMANENT CHANGE, 0 => TEMP CHANGE (GOES AWAY ON RESET)
;AC1=1 => AFFECT UNTIED MAP OF PHYSICAL TTY.  PRIVILEGED OP.
;    0 => AFFECT TEMP OR PERM MAP OF LINE.
;FINAL STATUS (TEMP/PERM PER AC0) STORED IN AC, -1 IF TTY NOT DD.
;AC6-8 = OPCODE:
;	0 - NOP, NEVER SKIPS, USEFUL FOR GETTING STATUS ALONE
;	1 - SET MAP FROM C(ADR), SKIPS IF ENTIRELY SUCCESSFUL (NO PRIVACY PROBLEM)
;	2 - IOR MAP FROM C(ADR), SET ANALOG IF ≠0. SKIPS ON COMPLETE SUCCESS.
;	3 - ANDCAM MAP FROM C(ADR), CLEAR ANALOG IF ≠0. FAILS ONLY ON BAD TTY #.
;	4 - RESET MAP. IN TEMP MODE THIS RESETS TEMP←PERM. IN PERM MODE PERM MAP
;			IS SET TO MAIN CHANNEL ALONE. FAILS ONLY ON BAD TTY #.
;	5 - GET LINE TIED TO.  NEVER SKIPS, RETURNS VDTIE ENTRY FOR TERMINAL
;	6 - TIE PHYSICAL TTY TO LINE IN AC RH (OR KBD-MAPPED LINE IF AC RH 0)
;	7 - ILLEGAL. CURRENTLY NO-OP.

↑VDSMAP:
	LDB AC1,[VDOP,,TAC]
	CAIL AC1,NVDOPS
	POPJ P,
	MOVE DSER,TAC
	CAIN AC1,6		;IF OP IS 6 (SET VDTIE),
	TLOA DSER,VDABSO	; SET BIT TO AFFECT PHYSICAL TTY
	XCTR XR,[SKIPA DAT,(TAC)]; AND DON'T USE AC RH AS A MASK
	MOVEI DAT,(TAC)		;  BUT AS IMMEDIATE OPERAND INSTEAD
	LDB TAC,[220700,,TAC]
	TLNE DSER,VDXBIT
	JRST VDMAP5
	JUMPN TAC,.+2
	HRRE TAC,JBTLIN(J)
	SUBI TAC,DDL0
	CAIGE TAC,DDNUM
	JUMPGE TAC,.+2
	JRST VDMAP4
	SKIPL VDDSP(AC1)
	JRST VDMAP2
	TLNE DSER,VDABSO
	JRST VDMP1A		;MUST BE PRIVILEGED TO HACK ABSOLUTE TTYS
	SKIPA AC2,JBTLIN(J)
VDMAP1:	MOVE AC2,JBTLIN(AC2)
	CAMN AC2,[-1]		;DETACHED?
	JRST VDMP1A
	CAIN TAC,-DDL0(AC2)
	JRST VDMAP2		;LET HIM BY IF IT'S HIS CHAN
	TLNE AC2,PTYLIN
	SKIPN AC2,PTYJOB-PTYL0(AC2)	;OR IF IT'S HIS VIA SOME PTY CHAIN
VDMP1A:	SKIPA AC2,JBTPRV(J)
	JRST VDMAP1
	TLNE AC2,UPGPRV		;OR IF HE HAS THE MAGIC PRIVILEGE
	JRST VDMAP2
	TLNE DSER,VDABSO
	JRST VDMAP3		;LOSE IF ABSOLUTE BIT AND NO UPG
	MOVE AC2,[TTYATC,,ASSCON+ASSPRG]
	SKIPE DDB,TTYTAB+DDL0(TAC)
	TDNN AC2,DEVMOD(DDB)
	JRST VDMAP2		;OR IF IT'S FREE
	LDB AC2,PJOBN
	CAIE AC2,(J)
	JRST VDMAP3
				;FALL THRU TO VDMAP2 IF HE OWNS THE CONSOLE
;VDMAP2 VDMAP3 VDMP30 VDMP31 VDGTIE VDMP32 VDMAP5 VDMAP4 VDDSP VDSTIE

VDMAP2:	HLL TAC,VDDSP(AC1)
	TLZ TAC,400000		;DON'T CONFUSE VDOUT, after all we're not a III
	PUSHJ P,@VDDSP(AC1)	;VDSTIE DEPENDS ON AOS (P) AT .+2
	TLNE TAC,200000		;DON'T SKIP IF NOT REQUESTED
	AOS (P)			;NOTE THIS BIT WAS CLEARED BY ANY FAILURE
VDMAP3:	TLNE DSER,VDXBIT!VDABSO
	JRST VDMP31
	TLNN DSER,VDPERM	;GIVE HIM APPROPRIATE FLAVOR OF STATUS
VDMP30:	SKIPN DAT,LETAB+DDL0(TAC)
	SKIPA TAC,VDPRM(TAC)
	MOVE TAC,VDTMP(DAT)
	JRST STOTAC

VDMP31:	HRRZ DAT,VDTIE(TAC)	;HE WANTS STATUS FOR PHYSICAL TTY
	JUMPE DAT,VDMP32	;UNTIED, GET VDMAP
	MOVEI TAC,-DDL0(DAT)	;TIED, GET TEMP (IF ANY) MAP OF WHO HE'S TIED TO
	JRST VDMP30

VDGTIE:	POP P,(P)		;FLUSH RETURN ADDRESS
	SKIPA TAC,VDTIE(TAC)
VDMP32:	MOVE TAC,VDMAP(TAC)
	JRST STOTAC

VDMAP5:	ADDI TAC,DDNUM		;HERE TO MAP "SHADOW" CHANNELS
	CAIGE TAC,DPYNUM+DDNUM
	JRST VDMAP2
VDMAP4:	XCTR XW,[SETOM (UUO)]	;NOT DD - USE POSSIBLE BUT UNLIKELY VALUE TO FLAG THIS.
	POPJ P,

VDSTIE:	CAIL TAC,DDNUM		;SET VDTIE: MUSTN'T BE SHADOW CHANNEL
	POPJ P,
	JUMPN DAT,VDSTI1	;JUMP IF EXPLICIT LINE GIVEN
	LDB DAT,[POINT 7,LINTAB+DDL0(TAC),35]
VDSTI1:	CAIL DAT,DDL0		;SEE IF IN RANGE
	CAIL DAT,DDL0+DDNUM
	POPJ P,
	AOS (P)			;SUCCESS
	MOVEM DAT,VDTIE(TAC)	;ALL OK, SET VDTIE
	JRST VDOUT1

VDDSP:	CPOPJ
	600000,,VDSET
	600000,,VDIOR
	600000,,VDACM
	600000,,VDRST
	VDGTIE			;FUNCTION 5 RETURNS VDTIE
	400000,,VDSTIE		;FUNCTION 6 SETS VDTIE
NVDOPS←←.-VDDSP
;VDSET VDIOR VDIOR1 VDACM VDRST VDRST1 VDNORM VDRST2 VDNOR2 VDNOR3

VDSET:	PUSHJ P,VDWCHK
	PUSHJ P,VDSTRU
	 MOVEM DAT,VDTMP(AC2)
	POPJ P,

VDIOR:	TRNN DAT,17
	JRST VDIOR1
	MOVEI AC3,17
	PUSHJ P,VDSTRU	;CLEAR ANALOG HERE SO THESE DON'T GET OR'ED
	 ANDCAM AC3,VDTMP(AC2)
VDIOR1:	PUSHJ P,VDWCHK
	PUSHJ P,VDSTRU
	 IORM DAT,VDTMP(AC2)
	POPJ P,

VDACM:	TRNE DAT,17
	TRO DAT,17	;ANYTHING IN ANALOG FIELD CLEARS IT ALL
	PUSHJ P,VDSTRU
	 ANDCAM DAT,VDTMP(AC2)
	POPJ P,

VDRST:	TLZ DSER,VDABSO
	JUMPL DSER,VDNORM
VDRST1:	SKIPN AC2,LETAB+DDL0(TAC)
	POPJ P,
	OFFSCN			;TURN OFF SCANNER CHANNEL
	MOVE AC3,VDPRM(TAC)
	MOVEM AC3,VDTMP(AC2)	;SET TEMP MAP FROM PERM
	ONSCN			;TURN ON SCANNER CHANNEL
	JRST VDRST2

↑VDNORM:SKIPN AC2,LETAB+DDL0(TAC)
	SKIPA AC1,AVLCHN
	HLRZ AC1,PRGNUM(AC2)	;GET NORMAL CHANNEL OF ARG (MAPPEE)
	PUSHJ P,VDBIT
	PUSHJ P,VDSTR1		;ALWAYS TREAT AS PERMANENT REGARDLESS OF DSER
	 MOVEM AC3,VDTMP(AC2)	;  (WHICH IS USED BY ESC/BREAK N CODE IN LINED)
VDRST2:	MOVSI AC3,400000
	SKIPE AC2,LETAB+DDL0(TAC)
	ANDCAM AC3,LETBPT(AC2)	;INDICATE NO TEMP MAP IN EFFECT
	MOVSI AC2,-DDNUM
	MOVEI AC1,DDL0(TAC)
VDNOR2:	SKIPL VDTIE(AC2)
	JRST VDNOR3
	LDB AC3,[POINT PUNITS,LINTAB+DDL0(AC2),35]
	CAIN AC3,(AC1)
	MOVEM AC1,VDTIE(AC2)
VDNOR3:	AOBJN AC2,VDNOR2
	JRST VDOUTP
;VDWCHK VDWCHL VDWOK VDWLUZ VDCCHK VDCCK0 VDCCK1 VDCCK2 VDCCK3

;ROUTINE TO BLESS BITS ABOUT TO BE TURNED ON FOR PRIVACY VIOLATION
;LOSING BITS ARE FLUSHED, AND SKIP FLAG IS CLEARED
VDWCHK:	MOVSI AC1,-40
VDWCHL:	JUMPGE DAT,VDWOK
	SKIPL DDTAB(AC1)
	JRST VDWOK
	HRRE AC3,JBTLIN(J)
	PUSHJ P,VDCCHK		;TRYING TO LOOK AT PRIVATE CHAN, SEE IF IT'S OK
	JRST VDWLUZ
VDWOK:	ROT DAT,1
	AOBJN AC1,VDWCHL
	ROT DAT,4
	TRNN DAT,17
	POPJ P,
	LDB AC1,[300,,DAT]
	IOR DAT,VDSYNC(AC1)
	POPJ P,

VDWLUZ:	TLZ DAT,400000
	TLZ TAC,200000
	JRST VDWOK

;ROUTINE TO SEE IF LOOKING AT PRIVATE CHAN IS LEGAL
;AC1=CHAN, TAC=MAPPED CONSOLE, AC3=MAPPING CONSOLE, J=MAPPING JOB.
↑VDCCHK:LDB AC2,[DDUSR(AC1)]
	CAIN AC2,100(TAC)
	JRST CPOPJ1		;CAN ALWAYS MAP CONSOLE TO ITSELF
VDCCK0:	TRNE AC2,300
	JRST VDCCK2		;CONSOLE CHAN
VDCCK1:	CAIN J,(AC2)
	JRST CPOPJ1		;JOB OWNS IT
	MOVE AC2,JBTLIN(AC2)
	AOJE AC2,CPOPJ		;DETACHED
	TLNN AC2,PTYLIN
	JRST VDCCK3
	MOVE AC2,PTYJOB-PTYL0-1(AC2)	;SEE IF IT CAN GET TO IT VIA PTY
	JRST VDCCK1

VDCCK2:	ADD AC2,[DDDLIN-1,,DDL0-100+1]
VDCCK3:	TLNE AC2,DDDLIN
	CAIE AC3,-1(AC2)		;JOB'S OWN CONSOLE WINS
	POPJ P,
	JRST CPOPJ1

BEND DPYSER
BEGIN WHOSER  ↔ SUBTTL WHO LINE GENERATOR ;	WHOINI
;R. HELLIWELL--6/APR/70

COMMENT ⊗
	THIS ROUTINE ALLOWS EACH LUCKY OWNER OF A DISPLAY
TO HAVE ONE LINE OF "WHO" INFORMATION ON HIS SCREEN AT ANY TIME
IT USES THE LINE EDITOR FOR ACTIVATION IN THE FOLLOWING MANNER.

	<ESC>W
	TO DISPLAY THE WHO LINE FOR THE JOB ATTACHED TO THIS DPY.

	<ESC><N>W
	TO DISPLAY THE WHO LINE FOR JOB N ON THIS DPY.

	<BREAK>W
	STOP THE WHO LINE.

LOOK FOR CODE IN THE LINE EDITOR AROUND THE LABEL "ESCW".
See also WHOQUE and WHOQDM in DPYSER.
WHOSER IS CALLED FROM CLKINT.
⊗



GLOBAL DDUSR

DISJSR←←24		;STORES RETURN
DISJMP←←20		;JUMP
DISNOP←←12		;GOOD NO-OP WITH NO BITS.
DEFINE CW (C1,B1,C2,B2,C3,B3) {<BYTE (8)<B1>,<B2>,<B3>(3)<C1>,<C2>,<C3>>!4}

;AC'S USED
;WHO IS FOR DPY # AND JOB STATUS WORD.
;TAC AND TAC1 AND AC2 ARE SORT OF TEMPORARY
;AC1 LOCATION OF FREE STORAGE BUFFER.
;AC3 BYTE POINTER TO FREE STORAGE, INDEXED BY AC1
;J CONTAINS JOB NUMBER OF WHO LINE.

;WHOPTR 0 = LINE IS FREE.
;      >0 = LINE IS WAITING TO BE QUEUED
;      -2 OR -1 = LINE HAS BEEN QUEUED.

WHO←TEM			;DPY INDEX AT TOP LEVEL.

↑WHOINI: POPJ P,
;CELLS FORMERLY CLEARED HERE ARE ALL BETWEEN SYSBEG AND SYSEND AND
;THUS GET ZEROED AT SYSINI
;WHOSER WHOIII WHODO WHODO9 WHODO4 WHODO3 WHODO2 WHODO1 WHOCLR WHODM WHODO5

LOSYS

↑WHOSER:MOVE	DAT,TIME
	TRNE	DAT,1			;EVEN TIC?
	POPJ	P,			;NO, SKIP IT.
	MOVEI	AC1,0
	EXCH	AC1,FREWAT				
	SKIPE	AC1			;WAITING TO GIVE BACK FREE STORAGE?
	PUSHJ	P,FSGIVE		;YES. DO IT.
;WE DO WHO LINES FOR 5 III DISPLAYS IN 10. TICKS, THEN
;ON THE 12.TH  TICK WE DO ONE DD LINE AND THE OTHER III.
WHOIII:	SOSL	WHO,WHONXT		;NEXT GUY TO DO.
	JRST	WHODO5			;JUMP IF THERE'S ANOTHER III TO DO
WHODO:	MOVE	TAC,DDOFF		;DATA DISK IS OFF?
	JUMPN	TAC,WHODO9		;JUMP IF DD IS OFF.
	MOVE	TAC,WHOPTR		;DD WHO LINE STILL BUSY?
	JUMPN	TAC,WHODO2		;IF SO, LEAVE EARLY.
WHODO9:	SOSLE	AC1,WHOKLU		;COUNT DOWN TO AVL MSG SHIFT
	JRST	WHODO4
	PUSHJ	P,WHODDC		;Update count of DD channels in use
	PUSHJ	P,DDAVST		;THIS MOVES AVAILABLE MESSAGE
	MOVEI	AC1,=300
	MOVEM	AC1,WHOKLU	;300 WHODO'S IS A MINUTE (BEFORE NEXT SHIFT OF MSG)
	MOVEI	WHO,DDAVLU		;WHOKLU SET, SERVICE AVLCHN NOW
	JRST	WHODO3

WHODO4:
IFN FTDM,<
	TRNN	AC1,1			;Check one DM line for every other DD done
	PUSHJ	P,WHODM			;DO A WHOLINE FOR A DATAMEDIA
>;FTDM
	SOSGE	WHO,WHDDNXT		;WHO'S NEXT FOR WHO
	PUSHJ	P,WHOSYS		;END OF DD.  RECALCULATE SYSTEM LINE
	LDB	WHO,[DDUSR(WHO)]	;MAP FROM DD CHANNEL TO TTY NUMBER
	CAIN	WHO,DDAVLU		;AVAILABLE CHANNEL?
	JRST	WHODO3			;YES, SKIP WHODO1
	CAIL	WHO,100
	CAILE	WHO,177
	JRST	WHODO2			;NOT USER'S CONSOLE
	SUBI	WHO,100-DDL0		;MAKE TTY NUMBER
	PUSHJ	P,WHODO1		;GO REFRESH ONE MORE DD WHO LINE
WHODO3:	HRRZM	WHO,WHOPTR		;SET TO FLAG WHOQUE.
WHODO2:	MOVEI	WHO,DPYNUM-1		;START ON III DISPLAYS AGAIN
	MOVEM	WHO,WHONXT		;SAVE INDEX OF WHO WAS DONE LAST
WHODO5:	MOVEI	WHO,DPYL0(WHO)		;WHODO1 NOW EXPECTS LINE NUMBER IN WHO
WHODO1:	HLL	WHO,LINTAB(WHO)		;GET DISPLAY-TYPE BIT IN LH
	MOVE	AC1,FRETAB(WHO)		;GET THE FREE STORAGE BLOCK
	MOVE	DDB,LETAB(WHO)		;GET PTR TO DPY HEADER
	JUMPE	DDB,WHOCLR		;JUMP IF NO DPY HEADER
	HRRZ	J,WHOTAB(DDB)		;GET JOB NUMBER FOR THIS LINE.
	MOVE	DAT,JBTSTS(J)		;GET JOB'S STATUS WORD
	TLNN	DAT,JNA			;IS IT STILL THERE?
	SETZB	J,WHOTAB(DDB)		;NO, FLUSH!
	JUMPE	J,WHOCLR		;JUMP IF NO WHO REQUEST
IFN FTDM,<
	TLNE	WHO,DMLIN
	JRST	DMWCHK			;See if previous wholine is done for this DM
DMWOK:
>;FTDM
					;CHECK FOR RELEASE OF FREE STORAGE
	JUMPE	AC1,WHOSET		;JUMP IF WE NEED TO MAKE FS BLOCK.
	JUMPGE	WHO,WHOLIN		;ALWAYS UPDATE SLOW PART FOR DD AND DM
	MOVE	DAT,WHDDNXT
	TRNN	DAT,3			;UPDATE WHOLE III AFTER 4 DATA DISKS
	JRST	WHOLIN			;COMPUTE ENTIRE LINE.
	JRST	ALWAYS			;JUST DO THE FAST PART THIS TIME

WHOCLR:	JUMPE	AC1,CPOPJ		;DO WE HAVE FREE STORAGE BLOCK
	SETZM	FRETAB(WHO)		;YES. CLEAR FRETAB
	HRRZM	AC1,FREWAT		;YES, QUEUE IT FOR NEXT TIC.
	JUMPGE	WHO,CPOPJ		;LEAVE IF THIS IS NOT A III
	HRRZ	DDB,LETAB(WHO)
	JUMPE	DDB,CPOPJ		;IF SLIPPED OUT FROM UNDER US, FORGET IT
	MOVEI	TAC,DISNOP		;RESET WHOCALL.
	MOVEM	TAC,WHOCALL(DDB)
	MOVSI	TAC,400000		;DONT SELECT III FOR SYS WHO LINE
	MOVNI	AC2,-DPYL0(WHO)
	LSH	TAC,(AC2)
	ANDCAM	TAC,WHOSEL		;TURN OFF SET BIT
	LSH	TAC,-=12		;DESELECT THIS III FOR SYS WHO LINE
	IORM	TAC,WHOSEL		;TURN ON RESET BIT
	HRRZ	AC3,PRGNUM(DDB)		;GET TTY NUMBER
	MOVEI	AC2,PSELB(DDB)		;INVENT A RESTARTING JMP FOR IT AND
	HRLI	AC2,DISJMP		;PUT IN RSTTBL SO PRGM WILL GET
	MOVSM	AC2,RSTTBL-DPYL0(AC3)	;STARTED AT ITS BEGINNING NEXT TIME.
	POPJ	P,

IFN FTDM,<
WHODM:	SKIPE	WHDMPT			;Any DM wholine yet to be queued?
	POPJ	P,			;Yes, don't do any more
	SOSL	WHO,NEXTDM
	JRST	WHODM2			;GO DO THIS TTY IF IT IS A DISPLAY (DM)
	MOVEI	WHO,SCNNUM-1		;CURRENT ONLY TTYS 0-17 CAN HAVE DM WHOLINES
	MOVEM	WHO,NEXTDM		;START OVER
WHODM2:	PUSHJ	P,WHODO1		;Skips for DM if ready for new wholine
	POPJ	P,			;DM's wholine is busy, or no job or dpy hdr
	MOVEI	AC1,(AC1)		;LH of AC1 will count text words to suppress
	MOVE	AC2,[-WLINK+WTEND,,DMWCOP] ;AOBJN ptr to copy of previous text
WHODM3:	MOVE	AC3,WTEND(AC1)		;Get new text word
	CAME	AC3,(AC2)
	JRST	WHODM4			;User line has changed
	AOBJN	AC1,.+1
	AOBJN	AC2,WHODM3
	TLZA	AC1,400000		;Don't need to output user line
WHODM4:	TLO	AC1,400000		;Make sure WHDMPT is non-zero
	HLL	WHO,AC1			;Pass number of text words to suppress
	MOVEM	WHO,WHDMPT		;Tell DPYCLK to queue up this DM's wholine
	POPJ	P,

DMWCHK:	HRRZ	AC2,DMWHO(DDB)		;Get pointer to first entry in DM WHO queue
	CAIE	AC2,DMWHO-QLINK(DDB)	;Does it point to header itself?
	POPJ	P,			;Direct return from WHODO1 to indicate busy
	AOS	(P)			;Make WHODO1 skip to indicate winning
	JUMPE	AC1,DMWCH3		;Jump if this is first time
	MOVSI	AC2,WTEND(AC1)		;Copy previous text of user part of wholine
	HRRI	AC2,DMWCOP
	BLT	AC2,DMWCOP+WLINK-WTEND-1
	JRST	DMWOK

DMWCH3:	SETZM	DMWCOP			;Make test for no change fail
	JRST	DMWOK
>;FTDM
;WHOSIX WHOSXX WSDPAD WSDPD3 WSDPD2 WSDPD0 WSDPD1 WPER2D W0PD2 DECPDF WHPRNT

WHOSIX:	MOVEI	AC2,6			;CHARACTER COUNT
WHOSXX:	MOVEI	TAC,0			;DATA IN TAC1
	LSHC	TAC,6
	ADDI	TAC," "
	IDPB	TAC,AC3
	SOJG	AC2,WHOSXX
	POPJ	P,

;WSDPAD - CALL WITH
;	AC3 = BYTE POINTER
;	AC2 = CHARACTER COUNT
;	TAC = DATA
;	TAC1, UCHN, DAT ARE CLOBBERED.
;	PRINTS NUMBER WITH LEADING SPACES.
;CALL WSDPD2 WITH UCHN = RADIX; DAT = PADDING CHARACTER. AC3,AC2,TAC AS ABOVE.
;CALL WSDPD3 WITH UCHN = RADIX.  USES BLANK PADDING.
WSDPAD:	MOVEI	UCHN,=10
WSDPD3:	MOVEI	DAT," "			;PADDING CHARACTER
WSDPD2:	IDIVI	TAC,(UCHN)
	HRLM	TAC1,(P)
	SUBI	AC2,1			;COUNT A CHARACTER GENERATED.
	JUMPE	TAC,WSDPD1
	PUSHJ	P,WSDPD2
WSDPD0:	HLRZ	TAC,(P)
	ADDI	TAC,"0"
	IDPB	TAC,AC3
	POPJ	P,

WSDPD1:	SOJL	AC2,WSDPD0
	IDPB	DAT,AC3
	JRST	WSDPD1

WPER2D:	IMULI	TAC,=100	;PRINT TAC/TAC1 AS A PERCENTAGE IN 2 DIGITS
	IDIV	TAC,TAC1
	CAIL	TAC,=100
	MOVEI	TAC,=99		;PRINT 99 FOR 100
				;FALL INTO W0PD2

;PRINT A 2 DIGIT DECIMAL NUMBER PADDED WITH A LEADING ZERO IF NECESSARY
;CALL WITH NUMBER IN TAC, BYTE POINTER IN AC3.  CLOBBERS TAC1
W0PD2:	IDIVI	TAC,=10
	ADDI	TAC,"0"
	IDPB	TAC,AC3
	ADDI	TAC1,"0"
	IDPB	TAC1,AC3
	POPJ	P,

;PRINT A DECIMAL NUMBER PADDING WITH FOLLOWING BLANKS
;	TAC = DATA
;	AC2 = CHARACTER COUNT
;	AC3 = BYTE POINTER
;TAC, AC2, TAC1 AND DAT ARE CLOBBERED
DECPDF:	MOVEI	DAT," "			;THIS IS THE CHARACTER TO PAD WITH
	PUSHJ	P,WHPRNT		;CONVERT TAC TO ASCII AND SAVE CHARACTERS
	SOJL	AC2,CPOPJ		;ANY PADDING NEEDED?
	IDPB	DAT,AC3			;YES.  PAD WITH A BLANK
	SOJGE	AC2,.-1			;MORE PADDING NEEDED?
	POPJ	P,			;NOPE

WHPRNT:	IDIVI	TAC,=10			;ROUTINE TO DO THE WORK FOR DECPDF
	HRLM	TAC1,(P)
	JUMPE	TAC,.+2
	PUSHJ	P,WHPRNT
	HLRZ	TAC,(P)
	ADDI	TAC,"0"
	IDPB	TAC,AC3			;DEPOSIT ONE DECIMAL DIGIT
	SUBI	AC2,1			;NOTE THAT WE HAVE PUT OUT A CHARACTER
	POPJ	P,
;ALWAYS ALWAY1 ALWAY2 ALWAY3 XTALL NOXTIM DOTIME WHOTIM WMIN

;THIS IS THE PART WE ALWAYS UPDATE.
ALWAYS:	ANDI	J,-1
	MOVE	DAT,JBTSTS(J)
	MOVE	AC3,[POINT 7,WTEND+4(AC1),34]
	MOVM	TAC,JOBQUE(J)		;GET QUEUE NUMBER.
	MOVE	TAC,QNAMS(TAC)		;GET PRINT NAME.
	TRO	TAC,1
	MOVEM	TAC,@AC3
	MOVEI	TAC," "
	CAMN	J,JOB			;CURRENTLY RUNNING JOB?
	MOVEI	TAC,"-"			;YES
	TLNE	DAT,SWP			;SWAPPED OUT?
	MOVEI	TAC,"*"			;YES
	TRNE	DAT,JLOCK		;LOCKED IN CORE?
	MOVEI	TAC,"⊗"			;YES
	DPB	TAC,AC3

	MOVEI	TAC," "
	MOVE	TAC1,SPWGO(J)		;SPACEWAR ON THE 10?
	JUMPE	TAC1,ALWAY1		;NO
	MOVEI	TAC,"\"			;YES
	MOVE	TAC1,SP2GO(J)		;SPACEWAR ON 6 ALSO?
	JUMPE	TAC1,ALWAY2		;NO
	MOVEI	TAC,"X"			;YES
	JRST	ALWAY2

ALWAY1:	MOVE	TAC1,SP2GO(J)		;SPACEWAR ON THE 6?
	JUMPE	TAC1,ALWAY2		;NO
	MOVEI	TAC,"/"			;YES
ALWAY2:	LDB	TAC1,PSEGN		;IS THERE A SEGMENT?
	JUMPE	TAC1,ALWAY3		;NO
	MOVE	TAC1,JBTSTS(TAC1)	;YES
	TLNE	TAC1,SWP		;IS IT SWAPPED OUT?
	MOVEI	TAC,"*"			;YES
ALWAY3:	IDPB	TAC,AC3

;PRINT XTIME INCREMENT
	MOVE	TAC,XTIME(J)		;GET RUN TIME AT LAST INTERACTION
	MOVEI	TAC1,"'"		;PUNCTUATE TICKS WITH RIGHT QUOTE
	TLZE	TAC,400000		; UNLESS NO-UPDATE FLAG SET
	MOVEI	TAC1,42			;IN WHICH CASE USE double QUOTE
	DPB	TAC1,[POINT 7,WTEND+13(AC1),27] ;DEPOSIT PUNCTUATOR
	MOVN	TAC,TAC
	ADD	TAC,TTIME(J)		;CALCULATE INCREMENT IN RUN TIME
	JUMPE	DDB,XTALL		;ALWAYS IF TTY (DDB=0)
	HLRZ	TAC1,WHOTAB(DDB)	;GET INCREMENT FROM LAST TIME
	CAIN	TAC1,(TAC)		;SAME?
	JRST	NOXTIM			;YES.  DON'T UPDATE INCREMENT
	HRLM	TAC,WHOTAB(DDB)		;NO.  SAVE INCREMENT THIS TIME FOR NEXT TIME
XTALL:	IDIVI	TAC,=60			;CONVERT TO SECONDS
	PUSH	P,TAC1			;SAVE TICKS
	MOVE	AC3,[POINT 7,WTEND+12(AC1),13]
	PUSHJ	P,WHOTIM		;PRINT X INCREMENT
	IBP	AC3			;SKIP OVER PUNCTUATOR (ALREADY DEPOSITED)
	POP	P,TAC			;RETRIEVE TICKS
	PUSHJ	P,W0PD2			;PRINT TICKS

NOXTIM:	MOVE	TAC,TTIME(J)		;GET RUN TIME
	JUMPE	DDB,DOTIME		;ALWAYS DO FOR TTY WHO (DDB=0)
	CAML	TAC,WHORUN(DDB)		;TIME TO UPDATE RUN TIME YET?
	JRST	DOTIME			;YES
	ADDI	TAC,=60			;MAYBE NOT.  IS WHORUN REASONABLE?
	CAML	TAC,WHORUN(DDB)
	POPJ	P,			;YES
	SUBI	TAC,=60			;NO, READJUST RUN TIME AND THEN UPDATE
DOTIME:	MOVE	DAT,TAC			;COPY RUN TIME
	IDIVI	TAC,=60			;LEAVE SECONDS IN TAC.
	SUBI	DAT,(TAC1)		;ADJUST DAT TO LAST WHOLE SECOND OF RUN TIME
	ADDI	DAT,=60			; AND THEN ADD ONE SECOND
	SKIPE	DDB			;NOT FOR TTY WHO
	MOVEM	DAT,WHORUN(DDB)		; AND SAVE THAT AS TIME FOR NEXT UPDATE
	MOVE	AC3,[POINT 7,WTEND+10(AC1),6]	;FALL INTO WHOTIM

WHOTIM:	IDIVI	TAC,=60*=60		;HOURS IN TAC, MINUTES, SECONDS IN TAC1
	JUMPE	TAC,[MOVEI DAT," "	;FILL HOURS FIELD WITH ONE SPACE
		DPB DAT,AC3
		MOVEI DAT,0		; AND ONE NULL.  THEN FILL MINUTES WITH NULLS
		IDPB DAT,AC3
		JRST WMIN]
	MOVEI	DAT,"0"			;FLAG TO FILL MINUTES FIELD WITH 0'S
	ADDI	TAC,"0"
	DPB	TAC,AC3
	MOVEI	TAC,":"
	IDPB	TAC,AC3
WMIN:	MOVE	TAC,TAC1
	IDIVI	TAC,=60
	PUSH	P,TAC1			;SAVE SECONDS
	MOVEI	UCHN,=10		;SET RADIX. DAT SET WITH FILL CHARACTER
	MOVEI	AC2,2			;NUMBER OF CHARACTERS TO FILL.
	PUSHJ	P,WSDPD2		;WRITE DECIMAL WITH FILL.
	MOVEI	TAC,":"
	IDPB	TAC,AC3
	POP	P,TAC
	JRST	W0PD2			;WRITE SECONDS AS TWO CHARACTERS.  RETURN.
;WHOSET WHOLIN WLRET WLRET1

; THIS ROUTINE SETS UP A NEW WHO TABLE FROM A PIECE OF FREE STORAGE

WHOSET:	MOVEI	AC3,WLINK+1		;GET SIZE.
	PUSHJ	P,FSGET			;GET FREE STORAGE.
	POPJ	P,			;NONE, RETURN.
	MOVEM	AC1,FRETAB(WHO)		;SAVE FREE STORAGE POINTER.
	MOVE	TAC,AC1
	HRLI	TAC,TITLE
	BLT	TAC,WLINK(AC1)		;PUT LINE MODEL INTO FREE STORAGE.
	MOVEI	AC2,177⊗8!27⊗1!1
	TLNE	WHO,DMLIN
	MOVEM	AC2,WLINK-1(AC1)	;Replace CRLF in DM wholine with EEOL
	SETZM	WHORUN(DDB)		;ZERO THE TIME TO UPDATE RUN TIME NEXT
	JUMPGE	WHO,WHOLIN		;AVOID SPECIAL STUFF EXCEPT FOR IIIs
	MOVEI	TAC,DISNOP		;IIIs DONT DO THEIR OWN SYSTEM WHO LINE
	MOVEM	TAC,2(AC1)		; SO A NO-OP REPLACES THE JMP TO SYS LINE
	HRLI	AC1,DISJMP
	MOVSM	AC1,WLINK(AC1)		;STORE JUMP BACK TO FRONT OF BLOCK.
	HRLI	AC1,DISJSR
	MOVE	AC3,LETAB(WHO)
	JUMPE	AC3,WHOCLR		;JUMP IF DPY HEADER DISAPPEARED
	MOVSM	AC1,WHOCALL(AC3)	;STORE JSR TO FS BLOCK WHERE III WILL HIT IT
	ANDI	AC1,-1			;CLEAR LEFT SIDE.
	MOVSI	TAC,400000		;SELECT THIS III FOR SYS WHO LINE
	MOVNI	AC2,-DPYL0(WHO)
	LSH	TAC,(AC2)
	ORM	TAC,WHOSEL		;TURN ON SET BIT
	LSH	TAC,-=12		;DONT DESELECT THIS III FOR SYS WHO LINE
	ANDCAM	TAC,WHOSEL		;TURN OFF RESET BIT
↑WHOLIN:PUSHJ	P,ALWAYS
;	HRRZ	TAC,WHOTAB(DDB)		;HAS JOB GONE AWAY?
;	JUMPE	TAC,CPOPJ		;YES. DON'T WORK AT IT.
	HRRZ	TAC,J
	MOVE	AC3,[POINT 7,WTEND(AC1)]
	MOVEI	AC2,2			;2 CHARACTERS
	PUSHJ	P,WSDPAD		;WRITE DECIMAL JOB NUMBER
	MOVE	AC3,[POINT 7,WTEND(AC1),27]
	MOVE	TAC1,PRJPRG(J)		;PROJECT-PROGRAMMER INITIALS.
	PUSHJ	P,WHOSIX		;DO SIXBIT OUTPUT
	HRRE	TAC,JBTLIN(J)		;GET LINE NUMBER AND SEE IF DETACHED
	JUMPL	TAC,[MOVE TAC1,[ASCID /  DET/]
		MOVEM TAC1,WTEND+2(AC1)
		JRST WLRET]
	MOVEI	AC2,5			;NOT DETACHED.  PRINT LINE NO IN 5 SPACES
	MOVEI	UCHN,10			;OCTAL RADIX
	PUSHJ	P,WSDPD3		;WRITE IT WITH BLANK PADDING
	MOVEI	TAC1," "		;PUT SPACE AFTER LINE NUMBER IF OWN LINE
	JUMPE	DDB,WLRET1		; (USE SPACE FOR TTY WHOLINE)
	HRRZ	TAC,JBTLIN(J)		;GET BACK LINE NUMBER
	CAIE	TAC,(WHO)		;JOB RUNNING ON THIS DPY?
WLRET:	MOVEI	TAC1,"#"		;NO
WLRET1:	DPB	TAC1,[POINT 7,WTEND+3(AC1),6]
;WSIZE WALIAS

	MOVE 	AC3,[POINT 7,WTEND+5(AC1),20]
	MOVE	TAC1,JOBNAM(J)			;JOB NAME
	PUSHJ	P,WHOSIX
	MOVEI	TAC1,(J)
	PUSHJ	P,CORSGT			;TAC1←CORESIZE IN WORDS
	LSH	TAC1,CSHIFT			;CONVERT TO PAGES OR K
	MOVE	TAC,TAC1
	MOVEI	AC2,4				;4 CHARACTERS OUT, PAD WITH BLANKS
	PUSHJ	P,WSDPAD			;WHOSER DECIMAL PAD OUTPUT

	MOVE	AC3,[POINT 7,WTEND+11(AC1),20]	;OVERALL RUN/WAIT PERCENTAGE
	MOVE	TAC,TTIME(J)			;RUN TIME
	MOVE	TAC1,JBTWAT(J)			;WAIT TIME
	JUMPGE	TAC1,.+2			;IS WAIT TIME HONEST?
	ADD	TAC1,UPTIME			;NO.  ADJUST IT
	PUSH	P,TAC1				;SAVE TOTAL WAIT TIME
	PUSHJ	P,WPER2D			;PRINT PERCENTAGE IN 2 COLS WITH LEADING ZERO

	MOVE	AC3,[POINT 7,WTEND+14(AC1),13]	;INCREMENTAL RUN/WAIT PERCENTAGE
	MOVE	TAC,TTIME(J)			;RUN TIME
	MOVE	TAC1,XTIME(J)			;RUN TIME LAST SAVED
	TLZ	TAC1,400000			;CLEAR NO-UPDATE BIT
	SUB	TAC,TAC1			;CALCULATE INCREMENTAL RUN TIME
	POP	P,TAC1				;RETRIEVE CURRENT WAIT TIME
	SUB	TAC1,JB2WAT(J)			;CALCULATE INCREMENTAL WAIT TIME
	PUSHJ	P,WPER2D			;PRINT PERCENTAGE IN 2 COLS WITH LEADING ZERO

	MOVS	TAC1,DSKOPS(J)			;GET NUMBER OF DSK OPS
	HLRZ	TAC,TAC1			;TOTAL NO OF DSK OPS
	SUBI	TAC,(TAC1)			;LESS PREVIOUS TOTAL
	MOVEI	AC2,6				;6 COLS
	PUSHJ	P,WSDPAD			;LEADING BLANKS, DECIMAL NUMBER

	LDB	TAC,PSEGN			;DOES HE HAVE A SECOND SEGMENT?
	JUMPE	TAC,[MOVEI TAC,DISNOP		;NO
		TLNE WHO,DMLIN
		MOVEI TAC,1			;DISNOP is not a no-op on DM
		MOVEM TAC,WTEND+16(AC1)
		MOVEM TAC,WTEND+17(AC1)
		JRST WALIAS]
	MOVE	AC3,[POINT 7,WTEND+16(AC1),6]	;YES
	MOVEI	TAC1,1
	MOVEM	TAC1,WTEND+16(AC1)
	MOVEM	TAC1,WTEND+17(AC1)
	MOVEI	TAC1," "
	DPB	TAC1,AC3			;PRECEDE SEGMENT NAME WITH 1 SPACE
	MOVE	TAC1,JOBNAM(TAC)
	MOVEI	AC2,7				;WRITE SIXBIT + 1 SPACE
	PUSHJ	P,WHOSXX

WALIAS:	MOVE	TAC1,DSKPPN(J)			;DOES HE HAVE AN ALIAS?
	JUMPE	TAC1,[MOVEI TAC,DISNOP		;NOPE
		TLNE WHO,DMLIN
		MOVEI TAC,1			;DISNOP is not a no-op on DM
		MOVEM TAC,WTEND+20(AC1)
		MOVEM TAC,WTEND+21(AC1)
		POPJ P,]
	MOVEI	TAC,1				;YES
	MOVEM	TAC,WTEND+20(AC1)
	MOVEM	TAC,WTEND+21(AC1)
	MOVE	AC3,[POINT 7,WTEND+20(AC1),6]
	MOVEI	TAC," "
	DPB	TAC,AC3
	MOVEI	TAC,"("
	IDPB	TAC,AC3
	PUSHJ	P,WHOSIX			;PUT IN 6 SIXBIT CHARS FROM DSKPPN
	MOVEI	TAC,")"				; SURROUNDED BY PARENTHESES
	IDPB	TAC,AC3
	POPJ	P,
;WHOSYS NONULL WHOSY1 WRUN1 WRUN2 WHODDC

↑WHOSYS:
	MOVN	TAC,TTIME		;GET CURRENT NULL TIME
	EXCH	TAC,LASTNL		;SAVE IT AND GET PREVIOUS NULL TIME
	ADD	TAC,TTIME		;FIND INCREMENT IN NULL TIME
	MOVN	TAC1,UPTIME		;GET CURRENT UPTIME
	EXCH	TAC1,LASTUP		;SAVE IT AND GET PREVIOUS UP TIME
	ADD	TAC1,UPTIME		;FIND INCREMENT IN UP TIME
	JUMPE	TAC1,NONULL
	IMULI	TAC,=100		;CALCULATE NULL TIME IN PERCENT
	IDIV	TAC,TAC1
	MOVE	AC3,[POINT 7,COMWHO+7,13]
	MOVEI	AC2,3			;PRINT NULL PERCENTAGE IN 3 SPACES,
	PUSHJ	P,WSDPAD		; PADDING WITH SPACES
NONULL:	MOVE	AC3,[POINT 7,COMWHO+15,13]
	HRRZ	TAC,TIMDAT		;GET TIME OF DAY IN SECS
	IDIVI	TAC,=60			;MINS INTO TAC, SECS INTO TAC1
	IDIVI	TAC,=60			;HOURS INTO TAC, MINS INTO TAC1
	PUSH	P,TAC1			;SAVE MINS
	PUSHJ	P,W0PD2		;WRITE HOURS AS 2 DECIMAL DIGITS, PADDING WITH 0'S
	IBP	AC3			;SKIP OVER COLON AFTER HOURS
	POP	P,TAC			;RETRIEVE MINS
	PUSHJ	P,W0PD2			; AND WRITE 2 DIGIT NUMBER

	MOVE	AC1,THSDAT		;GET TODAY'S DATE
	CAMN	AC1,WHODAT		;NEW DAY ARRIVED YET?
	JRST	WHOSY1			;NO. DONT RECOMPUTE DAY AND DATE
	MOVEM	AC1,WHODAT		;YES

	MOVE	AC3,[ASCID /     /]
	MOVEM	AC3,COMWHO+11		;PUT SPACES INTO WHOLINE
	MOVEM	AC3,COMWHO+12
	
	IDIVI	AC1,=31			;DAY INTO AC2
	PUSH	P,AC2			;SAVE DAY
	IDIVI	AC1,=12			;MONTH INTO AC2
	MOVE	AC1,MONTAB(AC2)		;GET TEXT OF MONTH
	DPB	AC1,[POINT 21,COMWHO+11,34]
	POP	P,TAC			;GET DAY BACK
	ADDI	TAC,1			; AND CORRECT IT
	MOVE	AC3,[POINT 7,COMWHO+12,6]
	MOVEI	AC2,2			;WRITE IT IN 2 COLS
	MOVEI	UCHN,=10		; IN DECIMAL
	MOVEI	DAT,0			; WITH LEADING NULLS
	PUSHJ	P,WSDPD2
	MOVE	TAC,WHODAT		;GET DATE AGAIN
	PUSHJ	P,DAYCNT		;CONVERT TO NUMBER OF DAYS SINCE 1-1-64
	IDIVI	TAC,7			;GET DAY OF WEEK (REMAINDER)
	LSH	TAC1,1			;(TABLE ENTRIES ARE 2 WORDS EACH)
	MOVE	TAC,DAYTAB(TAC1)
	ORI	TAC,1
	MOVEM	TAC,COMWHO+13		;STORE FIRST PART OF DAY
	MOVE	TAC,DAYTAB+1(TAC1)
	ORI	TAC,1
	MOVEM	TAC,COMWHO+14		;STORE SECOND HALF OF DAY

WHOSY1:	MOVE	TAC,DQCNT		;GET NBR OF JOBS IN DISK QUEUE
	MOVE	AC3,[POINT 7,COMWHO+10,13]
	MOVEI	AC2,2			; AND WRITE IT IN 2 COLS
	PUSHJ	P,WSDPAD		; PADDING WITH BLANKS

	HLLZ	AC2,DPYAVL+1		;PICK UP III SELECT WORD FOR AVL MSG
	MOVEI	TAC,"6"			;ASSUME ALL III'S IN USE
	TLZA	AC2,7777		;CLEAR ALL BUT 6 SELECT BITS
	LSH	AC2,1			;LOOK AT NEXT III BIT
	JUMPG	AC2,.-1			;JUMP IF THIS III IN USE BUT SOME NOT
	JUMPE	AC2,.+2			;JUMP IF REST OF III'S IN USE
	SOJA	TAC,.-3			;NOTE A FREE III
	DPB	TAC,[POINT 7,COMWHO+2,6] ;PLACE III COUNT INTO WHOLINE

PRINTX Change system wholine here when more than two high-speed dialup lines.
	MOVEI	TAC,"0"
	SKIPE	LETAB
	ADDI	TAC,1
	SKIPE	LETAB+1
	ADDI	TAC,1
	DPB	TAC,[POINT 7,COMWHO+1,20]

	PUSHJ	P,WHODDC		;Put out number of DD channels in use

	MOVE	AC1,JBSRUN		;GET BITS FOR JOBS RUN LATELY
	MOVE	AC2,JBSRUN+1
	LSHC	AC1,2*=36-JOBN		;ADJUST HIGHEST JOB'S BIT TO SIGN BIT OF AC1
	SETZB	TAC,JBSRUN		;TAC = # OF JOBS LOGGED IN.  CLEAR RUN BITS.
	SETZB	TAC1,JBSRUN+1		;TAC1= # OF JOBS RUN LATELY.
	SETZB	DDB,DAT			;DDB = CORE OF JOBS RUN LATELY.
					;DAT = CORE OF ALL JOBS
	MOVSI	WHO,JNA
	MOVEI	J,JOBN-1
WRUN1:	TDNN	WHO,JBTSTS(J)		;IS THIS JOB LOGGED IN?
	JRST	WRUN2			;NOPE
	ADDI	TAC,1			;YES.  COUNT HIM
	PUSH	P,TAC1
	MOVEI	TAC1,(J)
	PUSHJ	P,CORSGT		;TAC1←CORE SIZE OF JOB
	MOVE	UCHN,TAC1
	POP	P,TAC1
	ADD	DAT,UCHN		;ADD CORE SIZE TO TOTAL FOR ALL JOBS
	TLNN	AC1,400000		;HAS THIS JOB RUN LATELY?
	JRST	WRUN2			;NOPE.  FORGET HIM
	ADDI	TAC1,1			;YES.  COUNT HIM
	ADD	DDB,UCHN		; AND ADD IN HIS CORE
WRUN2:	LSHC	AC1,1			;PUT NEXT JOB'S BIT IN SIGN OF AC1
	SOJG	J,WRUN1			;MOVE ON TO NEXT JOB, IF ANY

	PUSH	P,TAC1			;SAVE # OF JOBS RUN LATELY
	PUSH	P,DAT			;SAVE TOTAL CORE SIZE
	MOVEI	AC2,4			;WRITE # OF JOBS IN 4 SPACES,
	PUSHJ	P,WSDPAD		; PADDING WITH BLANKS,
	IBP	AC3			; AND SKIP OVER THE COMMA (EG: 12,888)
	POP	P,TAC			;GET BACK TOTAL CORE SIZE,
	LSH	TAC,CSHIFT		; CONVERT TO K OR PAGES
	MOVEI	AC2,4			; AND PRINT IN 4 SPACES
	PUSHJ	P,DECPDF		; WITH FOLLOWING BLANKS
	POP	P,TAC			;GET BACK # OF JOBS RUN LATELY
	MOVEI	AC2,3			; AND WRITE IT IN 3 SPACES,
	PUSHJ	P,WSDPAD		; PADDING WITH BLANKS,
	IBP	AC3			; AND SKIP OVER THE COMMA AGAIN
	MOVE	TAC,DDB			;GET CORE OF JOBS RUN LATELY,
	LSH	TAC,CSHIFT		; CONVERT TO K OR PAGES
	MOVEI	AC2,4			;WRITE IT IN 4 SPACES,
	PUSHJ	P,DECPDF		; PADDING WITH FOLLOWING BLANKS

	MOVE	TAC,CORMAX		;GET AMOUNT OF AVAILABLE CORE,
	LSH	TAC,CSHIFT		; CONVERT TO K OR PAGES
	MOVEI	AC2,3			; AND PRINT IT IN 4 SPACES,
	PUSHJ	P,WSDPAD		; PADDING WITH BLANKS

	MOVEI	WHO,37			;START OVER WITH FIRST DD CHAN
	MOVEM	WHO,WHDDNXT
	POPJ	P,

WHODDC:	MOVE	AC3,[POINT 7,COMWHO+2,20]
	MOVN	TAC,DDFCNT		;GET NUMBER OF FREE DD CHANS
	ADDI	TAC,=31			; AND SUBTRACT FROM TOTAL NUMBER
	MOVEI	AC2,2			;PRINT NUMBER OF DD CHANS IN USE
	JRST	WSDPAD			; IN 2 SPACES PADDING WITH BLANKS

HISYS

BEND WHOSER